← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/postgresql-9.1/oneiric-security

« back to all changes in this revision

Viewing changes to contrib/seg/seg--1.0.sql

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/seg/seg--1.0.sql
 
1
/* contrib/seg/seg--1.0.sql */
 
2
 
 
3
-- Create the user-defined type for 1-D floating point intervals (seg)
 
4
 
 
5
CREATE FUNCTION seg_in(cstring)
 
6
RETURNS seg
 
7
AS 'MODULE_PATHNAME'
 
8
LANGUAGE C STRICT IMMUTABLE;
 
9
 
 
10
CREATE FUNCTION seg_out(seg)
 
11
RETURNS cstring
 
12
AS 'MODULE_PATHNAME'
 
13
LANGUAGE C STRICT IMMUTABLE;
 
14
 
 
15
CREATE TYPE seg (
 
16
        INTERNALLENGTH = 12,
 
17
        INPUT = seg_in,
 
18
        OUTPUT = seg_out
 
19
);
 
20
 
 
21
COMMENT ON TYPE seg IS
 
22
'floating point interval ''FLOAT .. FLOAT'', ''.. FLOAT'', ''FLOAT ..'' or ''FLOAT''';
 
23
 
 
24
--
 
25
-- External C-functions for R-tree methods
 
26
--
 
27
 
 
28
-- Left/Right methods
 
29
 
 
30
CREATE FUNCTION seg_over_left(seg, seg)
 
31
RETURNS bool
 
32
AS 'MODULE_PATHNAME'
 
33
LANGUAGE C STRICT IMMUTABLE;
 
34
 
 
35
COMMENT ON FUNCTION seg_over_left(seg, seg) IS
 
36
'overlaps or is left of';
 
37
 
 
38
CREATE FUNCTION seg_over_right(seg, seg)
 
39
RETURNS bool
 
40
AS 'MODULE_PATHNAME'
 
41
LANGUAGE C STRICT IMMUTABLE;
 
42
 
 
43
COMMENT ON FUNCTION seg_over_right(seg, seg) IS
 
44
'overlaps or is right of';
 
45
 
 
46
CREATE FUNCTION seg_left(seg, seg)
 
47
RETURNS bool
 
48
AS 'MODULE_PATHNAME'
 
49
LANGUAGE C STRICT IMMUTABLE;
 
50
 
 
51
COMMENT ON FUNCTION seg_left(seg, seg) IS
 
52
'is left of';
 
53
 
 
54
CREATE FUNCTION seg_right(seg, seg)
 
55
RETURNS bool
 
56
AS 'MODULE_PATHNAME'
 
57
LANGUAGE C STRICT IMMUTABLE;
 
58
 
 
59
COMMENT ON FUNCTION seg_right(seg, seg) IS
 
60
'is right of';
 
61
 
 
62
 
 
63
-- Scalar comparison methods
 
64
 
 
65
CREATE FUNCTION seg_lt(seg, seg)
 
66
RETURNS bool
 
67
AS 'MODULE_PATHNAME'
 
68
LANGUAGE C STRICT IMMUTABLE;
 
69
 
 
70
COMMENT ON FUNCTION seg_lt(seg, seg) IS
 
71
'less than';
 
72
 
 
73
CREATE FUNCTION seg_le(seg, seg)
 
74
RETURNS bool
 
75
AS 'MODULE_PATHNAME'
 
76
LANGUAGE C STRICT IMMUTABLE;
 
77
 
 
78
COMMENT ON FUNCTION seg_le(seg, seg) IS
 
79
'less than or equal';
 
80
 
 
81
CREATE FUNCTION seg_gt(seg, seg)
 
82
RETURNS bool
 
83
AS 'MODULE_PATHNAME'
 
84
LANGUAGE C STRICT IMMUTABLE;
 
85
 
 
86
COMMENT ON FUNCTION seg_gt(seg, seg) IS
 
87
'greater than';
 
88
 
 
89
CREATE FUNCTION seg_ge(seg, seg)
 
90
RETURNS bool
 
91
AS 'MODULE_PATHNAME'
 
92
LANGUAGE C STRICT IMMUTABLE;
 
93
 
 
94
COMMENT ON FUNCTION seg_ge(seg, seg) IS
 
95
'greater than or equal';
 
96
 
 
97
CREATE FUNCTION seg_contains(seg, seg)
 
98
RETURNS bool
 
99
AS 'MODULE_PATHNAME'
 
100
LANGUAGE C STRICT IMMUTABLE;
 
101
 
 
102
COMMENT ON FUNCTION seg_contains(seg, seg) IS
 
103
'contains';
 
104
 
 
105
CREATE FUNCTION seg_contained(seg, seg)
 
106
RETURNS bool
 
107
AS 'MODULE_PATHNAME'
 
108
LANGUAGE C STRICT IMMUTABLE;
 
109
 
 
110
COMMENT ON FUNCTION seg_contained(seg, seg) IS
 
111
'contained in';
 
112
 
 
113
CREATE FUNCTION seg_overlap(seg, seg)
 
114
RETURNS bool
 
115
AS 'MODULE_PATHNAME'
 
116
LANGUAGE C STRICT IMMUTABLE;
 
117
 
 
118
COMMENT ON FUNCTION seg_overlap(seg, seg) IS
 
119
'overlaps';
 
120
 
 
121
CREATE FUNCTION seg_same(seg, seg)
 
122
RETURNS bool
 
123
AS 'MODULE_PATHNAME'
 
124
LANGUAGE C STRICT IMMUTABLE;
 
125
 
 
126
COMMENT ON FUNCTION seg_same(seg, seg) IS
 
127
'same as';
 
128
 
 
129
CREATE FUNCTION seg_different(seg, seg)
 
130
RETURNS bool
 
131
AS 'MODULE_PATHNAME'
 
132
LANGUAGE C STRICT IMMUTABLE;
 
133
 
 
134
COMMENT ON FUNCTION seg_different(seg, seg) IS
 
135
'different';
 
136
 
 
137
-- support routines for indexing
 
138
 
 
139
CREATE FUNCTION seg_cmp(seg, seg)
 
140
RETURNS int4
 
141
AS 'MODULE_PATHNAME'
 
142
LANGUAGE C STRICT IMMUTABLE;
 
143
 
 
144
COMMENT ON FUNCTION seg_cmp(seg, seg) IS 'btree comparison function';
 
145
 
 
146
CREATE FUNCTION seg_union(seg, seg)
 
147
RETURNS seg
 
148
AS 'MODULE_PATHNAME'
 
149
LANGUAGE C STRICT IMMUTABLE;
 
150
 
 
151
CREATE FUNCTION seg_inter(seg, seg)
 
152
RETURNS seg
 
153
AS 'MODULE_PATHNAME'
 
154
LANGUAGE C STRICT IMMUTABLE;
 
155
 
 
156
CREATE FUNCTION seg_size(seg)
 
157
RETURNS float4
 
158
AS 'MODULE_PATHNAME'
 
159
LANGUAGE C STRICT IMMUTABLE;
 
160
 
 
161
-- miscellaneous
 
162
 
 
163
CREATE FUNCTION seg_center(seg)
 
164
RETURNS float4
 
165
AS 'MODULE_PATHNAME'
 
166
LANGUAGE C STRICT IMMUTABLE;
 
167
 
 
168
CREATE FUNCTION seg_upper(seg)
 
169
RETURNS float4
 
170
AS 'MODULE_PATHNAME'
 
171
LANGUAGE C STRICT IMMUTABLE;
 
172
 
 
173
CREATE FUNCTION seg_lower(seg)
 
174
RETURNS float4
 
175
AS 'MODULE_PATHNAME'
 
176
LANGUAGE C STRICT IMMUTABLE;
 
177
 
 
178
 
 
179
--
 
180
-- OPERATORS
 
181
--
 
182
 
 
183
CREATE OPERATOR < (
 
184
        LEFTARG = seg,
 
185
        RIGHTARG = seg,
 
186
        PROCEDURE = seg_lt,
 
187
        COMMUTATOR = '>',
 
188
        NEGATOR = '>=',
 
189
        RESTRICT = scalarltsel,
 
190
        JOIN = scalarltjoinsel
 
191
);
 
192
 
 
193
CREATE OPERATOR <= (
 
194
        LEFTARG = seg,
 
195
        RIGHTARG = seg,
 
196
        PROCEDURE = seg_le,
 
197
        COMMUTATOR = '>=',
 
198
        NEGATOR = '>',
 
199
        RESTRICT = scalarltsel,
 
200
        JOIN = scalarltjoinsel
 
201
);
 
202
 
 
203
CREATE OPERATOR > (
 
204
        LEFTARG = seg,
 
205
        RIGHTARG = seg,
 
206
        PROCEDURE = seg_gt,
 
207
        COMMUTATOR = '<',
 
208
        NEGATOR = '<=',
 
209
        RESTRICT = scalargtsel,
 
210
        JOIN = scalargtjoinsel
 
211
);
 
212
 
 
213
CREATE OPERATOR >= (
 
214
        LEFTARG = seg,
 
215
        RIGHTARG = seg,
 
216
        PROCEDURE = seg_ge,
 
217
        COMMUTATOR = '<=',
 
218
        NEGATOR = '<',
 
219
        RESTRICT = scalargtsel,
 
220
        JOIN = scalargtjoinsel
 
221
);
 
222
 
 
223
CREATE OPERATOR << (
 
224
        LEFTARG = seg,
 
225
        RIGHTARG = seg,
 
226
        PROCEDURE = seg_left,
 
227
        COMMUTATOR = '>>',
 
228
        RESTRICT = positionsel,
 
229
        JOIN = positionjoinsel
 
230
);
 
231
 
 
232
CREATE OPERATOR &< (
 
233
        LEFTARG = seg,
 
234
        RIGHTARG = seg,
 
235
        PROCEDURE = seg_over_left,
 
236
        RESTRICT = positionsel,
 
237
        JOIN = positionjoinsel
 
238
);
 
239
 
 
240
CREATE OPERATOR && (
 
241
        LEFTARG = seg,
 
242
        RIGHTARG = seg,
 
243
        PROCEDURE = seg_overlap,
 
244
        COMMUTATOR = '&&',
 
245
        RESTRICT = areasel,
 
246
        JOIN = areajoinsel
 
247
);
 
248
 
 
249
CREATE OPERATOR &> (
 
250
        LEFTARG = seg,
 
251
        RIGHTARG = seg,
 
252
        PROCEDURE = seg_over_right,
 
253
        RESTRICT = positionsel,
 
254
        JOIN = positionjoinsel
 
255
);
 
256
 
 
257
CREATE OPERATOR >> (
 
258
        LEFTARG = seg,
 
259
        RIGHTARG = seg,
 
260
        PROCEDURE = seg_right,
 
261
        COMMUTATOR = '<<',
 
262
        RESTRICT = positionsel,
 
263
        JOIN = positionjoinsel
 
264
);
 
265
 
 
266
CREATE OPERATOR = (
 
267
        LEFTARG = seg,
 
268
        RIGHTARG = seg,
 
269
        PROCEDURE = seg_same,
 
270
        COMMUTATOR = '=',
 
271
        NEGATOR = '<>',
 
272
        RESTRICT = eqsel,
 
273
        JOIN = eqjoinsel,
 
274
        MERGES
 
275
);
 
276
 
 
277
CREATE OPERATOR <> (
 
278
        LEFTARG = seg,
 
279
        RIGHTARG = seg,
 
280
        PROCEDURE = seg_different,
 
281
        COMMUTATOR = '<>',
 
282
        NEGATOR = '=',
 
283
        RESTRICT = neqsel,
 
284
        JOIN = neqjoinsel
 
285
);
 
286
 
 
287
CREATE OPERATOR @> (
 
288
        LEFTARG = seg,
 
289
        RIGHTARG = seg,
 
290
        PROCEDURE = seg_contains,
 
291
        COMMUTATOR = '<@',
 
292
        RESTRICT = contsel,
 
293
        JOIN = contjoinsel
 
294
);
 
295
 
 
296
CREATE OPERATOR <@ (
 
297
        LEFTARG = seg,
 
298
        RIGHTARG = seg,
 
299
        PROCEDURE = seg_contained,
 
300
        COMMUTATOR = '@>',
 
301
        RESTRICT = contsel,
 
302
        JOIN = contjoinsel
 
303
);
 
304
 
 
305
-- obsolete:
 
306
CREATE OPERATOR @ (
 
307
        LEFTARG = seg,
 
308
        RIGHTARG = seg,
 
309
        PROCEDURE = seg_contains,
 
310
        COMMUTATOR = '~',
 
311
        RESTRICT = contsel,
 
312
        JOIN = contjoinsel
 
313
);
 
314
 
 
315
CREATE OPERATOR ~ (
 
316
        LEFTARG = seg,
 
317
        RIGHTARG = seg,
 
318
        PROCEDURE = seg_contained,
 
319
        COMMUTATOR = '@',
 
320
        RESTRICT = contsel,
 
321
        JOIN = contjoinsel
 
322
);
 
323
 
 
324
 
 
325
-- define the GiST support methods
 
326
CREATE FUNCTION gseg_consistent(internal,seg,int,oid,internal)
 
327
RETURNS bool
 
328
AS 'MODULE_PATHNAME'
 
329
LANGUAGE C IMMUTABLE STRICT;
 
330
 
 
331
CREATE FUNCTION gseg_compress(internal)
 
332
RETURNS internal
 
333
AS 'MODULE_PATHNAME'
 
334
LANGUAGE C IMMUTABLE STRICT;
 
335
 
 
336
CREATE FUNCTION gseg_decompress(internal)
 
337
RETURNS internal
 
338
AS 'MODULE_PATHNAME'
 
339
LANGUAGE C IMMUTABLE STRICT;
 
340
 
 
341
CREATE FUNCTION gseg_penalty(internal,internal,internal)
 
342
RETURNS internal
 
343
AS 'MODULE_PATHNAME'
 
344
LANGUAGE C IMMUTABLE STRICT;
 
345
 
 
346
CREATE FUNCTION gseg_picksplit(internal, internal)
 
347
RETURNS internal
 
348
AS 'MODULE_PATHNAME'
 
349
LANGUAGE C IMMUTABLE STRICT;
 
350
 
 
351
CREATE FUNCTION gseg_union(internal, internal)
 
352
RETURNS seg
 
353
AS 'MODULE_PATHNAME'
 
354
LANGUAGE C IMMUTABLE STRICT;
 
355
 
 
356
CREATE FUNCTION gseg_same(seg, seg, internal)
 
357
RETURNS internal
 
358
AS 'MODULE_PATHNAME'
 
359
LANGUAGE C IMMUTABLE STRICT;
 
360
 
 
361
 
 
362
-- Create the operator classes for indexing
 
363
 
 
364
CREATE OPERATOR CLASS seg_ops
 
365
    DEFAULT FOR TYPE seg USING btree AS
 
366
        OPERATOR        1       < ,
 
367
        OPERATOR        2       <= ,
 
368
        OPERATOR        3       = ,
 
369
        OPERATOR        4       >= ,
 
370
        OPERATOR        5       > ,
 
371
        FUNCTION        1       seg_cmp(seg, seg);
 
372
 
 
373
CREATE OPERATOR CLASS gist_seg_ops
 
374
DEFAULT FOR TYPE seg USING gist
 
375
AS
 
376
        OPERATOR        1       << ,
 
377
        OPERATOR        2       &< ,
 
378
        OPERATOR        3       && ,
 
379
        OPERATOR        4       &> ,
 
380
        OPERATOR        5       >> ,
 
381
        OPERATOR        6       = ,
 
382
        OPERATOR        7       @> ,
 
383
        OPERATOR        8       <@ ,
 
384
        OPERATOR        13      @ ,
 
385
        OPERATOR        14      ~ ,
 
386
        FUNCTION        1       gseg_consistent (internal, seg, int, oid, internal),
 
387
        FUNCTION        2       gseg_union (internal, internal),
 
388
        FUNCTION        3       gseg_compress (internal),
 
389
        FUNCTION        4       gseg_decompress (internal),
 
390
        FUNCTION        5       gseg_penalty (internal, internal, internal),
 
391
        FUNCTION        6       gseg_picksplit (internal, internal),
 
392
        FUNCTION        7       gseg_same (seg, seg, internal);