← Back to branch summary

~vcs-imports/mammoth-replicator/trunk

« back to all changes in this revision

Viewing changes to contrib/cube/cube.sql.in

  • Committer: alvherre
  • Date: 2005-12-16 21:24:52 UTC
  • Revision ID: svn-v4:db760fc0-0f08-0410-9d63-cc6633f64896:trunk:1
Initial import of the REL8_0_3 sources from the Pgsql CVS repository.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/cube/cube.sql.in
 
1
-- Create the user-defined type for N-dimensional boxes
 
2
-- 
 
3
 
 
4
-- Adjust this setting to control where the objects get created.
 
5
SET search_path = public;
 
6
 
 
7
CREATE OR REPLACE FUNCTION cube_in(cstring)
 
8
RETURNS cube
 
9
AS 'MODULE_PATHNAME'
 
10
LANGUAGE 'C' IMMUTABLE STRICT;
 
11
 
 
12
CREATE OR REPLACE FUNCTION cube_out(cube)
 
13
RETURNS cstring
 
14
AS 'MODULE_PATHNAME'
 
15
LANGUAGE 'c'IMMUTABLE STRICT;
 
16
 
 
17
CREATE TYPE cube (
 
18
        INTERNALLENGTH = variable,
 
19
        INPUT = cube_in,
 
20
        OUTPUT = cube_out
 
21
);
 
22
 
 
23
COMMENT ON TYPE cube IS 'multi-dimensional cube ''(FLOAT-1, FLOAT-2, ..., FLOAT-N), (FLOAT-1, FLOAT-2, ..., FLOAT-N)''';
 
24
 
 
25
-- Convert from text to cube
 
26
 
 
27
CREATE OR REPLACE FUNCTION cube(text) RETURNS cube
 
28
AS 'MODULE_PATHNAME'
 
29
LANGUAGE 'C' IMMUTABLE STRICT;
 
30
 
 
31
COMMENT ON FUNCTION cube(text) IS 'convert text to cube';
 
32
 
 
33
CREATE CAST (text AS cube) WITH FUNCTION cube(text) AS ASSIGNMENT;
 
34
 
 
35
--
 
36
-- External C-functions for R-tree methods
 
37
--
 
38
 
 
39
-- Left/Right methods
 
40
 
 
41
CREATE OR REPLACE FUNCTION cube_over_left(cube, cube)
 
42
RETURNS bool
 
43
AS 'MODULE_PATHNAME'
 
44
LANGUAGE 'C' IMMUTABLE STRICT;
 
45
 
 
46
COMMENT ON FUNCTION cube_over_left(cube, cube) IS 'is over and left of (NOT IMPLEMENTED)';
 
47
 
 
48
CREATE OR REPLACE FUNCTION cube_over_right(cube, cube)
 
49
RETURNS bool
 
50
AS 'MODULE_PATHNAME'
 
51
LANGUAGE 'C' IMMUTABLE STRICT;
 
52
 
 
53
COMMENT ON FUNCTION cube_over_right(cube, cube) IS 'is over and right of (NOT IMPLEMENTED)';
 
54
 
 
55
CREATE OR REPLACE FUNCTION cube_left(cube, cube)
 
56
RETURNS bool
 
57
AS 'MODULE_PATHNAME'
 
58
LANGUAGE 'C' IMMUTABLE STRICT;
 
59
 
 
60
COMMENT ON FUNCTION cube_left(cube, cube) IS
 
61
'is left of (NOT IMPLEMENTED)';
 
62
 
 
63
CREATE OR REPLACE FUNCTION cube_right(cube, cube)
 
64
RETURNS bool
 
65
AS 'MODULE_PATHNAME'
 
66
LANGUAGE 'C' IMMUTABLE STRICT;
 
67
 
 
68
COMMENT ON FUNCTION cube_right(cube, cube) IS 'is right of (NOT IMPLEMENTED)';
 
69
 
 
70
 
 
71
-- Comparison methods
 
72
 
 
73
CREATE OR REPLACE FUNCTION cube_eq(cube, cube)
 
74
RETURNS bool
 
75
AS 'MODULE_PATHNAME'
 
76
LANGUAGE 'C' IMMUTABLE STRICT;
 
77
 
 
78
COMMENT ON FUNCTION cube_eq(cube, cube) IS 'same as';
 
79
 
 
80
CREATE OR REPLACE FUNCTION cube_ne(cube, cube)
 
81
RETURNS bool
 
82
AS 'MODULE_PATHNAME'
 
83
LANGUAGE 'C' IMMUTABLE STRICT;
 
84
 
 
85
COMMENT ON FUNCTION cube_ne(cube, cube) IS 'different';
 
86
 
 
87
CREATE OR REPLACE FUNCTION cube_lt(cube, cube)
 
88
RETURNS bool
 
89
AS 'MODULE_PATHNAME'
 
90
LANGUAGE 'C' IMMUTABLE STRICT;
 
91
 
 
92
COMMENT ON FUNCTION cube_lt(cube, cube) IS 'lower than';
 
93
 
 
94
CREATE OR REPLACE FUNCTION cube_gt(cube, cube)
 
95
RETURNS bool
 
96
AS 'MODULE_PATHNAME'
 
97
LANGUAGE 'C' IMMUTABLE STRICT;
 
98
 
 
99
COMMENT ON FUNCTION cube_gt(cube, cube) IS 'greater than';
 
100
 
 
101
CREATE OR REPLACE FUNCTION cube_le(cube, cube)
 
102
RETURNS bool
 
103
AS 'MODULE_PATHNAME'
 
104
LANGUAGE 'C' IMMUTABLE STRICT;
 
105
 
 
106
COMMENT ON FUNCTION cube_le(cube, cube) IS 'lower than or equal to';
 
107
 
 
108
CREATE OR REPLACE FUNCTION cube_ge(cube, cube)
 
109
RETURNS bool
 
110
AS 'MODULE_PATHNAME'
 
111
LANGUAGE 'C' IMMUTABLE STRICT;
 
112
 
 
113
COMMENT ON FUNCTION cube_ge(cube, cube) IS 'greater than or equal to';
 
114
 
 
115
CREATE OR REPLACE FUNCTION cube_cmp(cube, cube)
 
116
RETURNS int4
 
117
AS 'MODULE_PATHNAME'
 
118
LANGUAGE 'C' IMMUTABLE STRICT;
 
119
 
 
120
COMMENT ON FUNCTION cube_cmp(cube, cube) IS 'btree comparison function';
 
121
 
 
122
CREATE OR REPLACE FUNCTION cube_contains(cube, cube)
 
123
RETURNS bool
 
124
AS 'MODULE_PATHNAME'
 
125
LANGUAGE 'C' IMMUTABLE STRICT;
 
126
 
 
127
COMMENT ON FUNCTION cube_contains(cube, cube) IS 'contains';
 
128
 
 
129
CREATE OR REPLACE FUNCTION cube_contained(cube, cube)
 
130
RETURNS bool
 
131
AS 'MODULE_PATHNAME'
 
132
LANGUAGE 'C' IMMUTABLE STRICT;
 
133
 
 
134
COMMENT ON FUNCTION cube_contained(cube, cube) IS 'contained in';
 
135
 
 
136
CREATE OR REPLACE FUNCTION cube_overlap(cube, cube)
 
137
RETURNS bool
 
138
AS 'MODULE_PATHNAME'
 
139
LANGUAGE 'C' IMMUTABLE STRICT;
 
140
 
 
141
COMMENT ON FUNCTION cube_overlap(cube, cube) IS 'overlaps';
 
142
 
 
143
-- support routines for indexing
 
144
 
 
145
CREATE OR REPLACE FUNCTION cube_union(cube, cube)
 
146
RETURNS cube
 
147
AS 'MODULE_PATHNAME'
 
148
LANGUAGE 'C' IMMUTABLE STRICT;
 
149
 
 
150
CREATE OR REPLACE FUNCTION cube_inter(cube, cube)
 
151
RETURNS cube
 
152
AS 'MODULE_PATHNAME'
 
153
LANGUAGE 'C' IMMUTABLE STRICT;
 
154
 
 
155
CREATE OR REPLACE FUNCTION cube_size(cube)
 
156
RETURNS float8
 
157
AS 'MODULE_PATHNAME'
 
158
LANGUAGE 'C' IMMUTABLE STRICT;
 
159
 
 
160
 
 
161
-- Misc N-dimensional functions
 
162
 
 
163
-- proximity routines
 
164
 
 
165
CREATE OR REPLACE FUNCTION cube_distance(cube, cube)
 
166
RETURNS float8
 
167
AS 'MODULE_PATHNAME'
 
168
LANGUAGE 'C' IMMUTABLE STRICT;
 
169
 
 
170
-- Extracting elements functions
 
171
 
 
172
CREATE OR REPLACE FUNCTION cube_dim(cube)
 
173
RETURNS int4
 
174
AS 'MODULE_PATHNAME'
 
175
LANGUAGE 'C' IMMUTABLE STRICT;
 
176
 
 
177
CREATE OR REPLACE FUNCTION cube_ll_coord(cube, int4)
 
178
RETURNS float8
 
179
AS 'MODULE_PATHNAME'
 
180
LANGUAGE 'C' IMMUTABLE STRICT;
 
181
 
 
182
CREATE OR REPLACE FUNCTION cube_ur_coord(cube, int4)
 
183
RETURNS float8
 
184
AS 'MODULE_PATHNAME'
 
185
LANGUAGE 'C' IMMUTABLE STRICT;
 
186
 
 
187
CREATE OR REPLACE FUNCTION cube(float8) RETURNS cube
 
188
AS 'MODULE_PATHNAME', 'cube_f8'
 
189
LANGUAGE 'C' IMMUTABLE STRICT;
 
190
 
 
191
CREATE OR REPLACE FUNCTION cube(float8, float8) RETURNS cube
 
192
AS 'MODULE_PATHNAME', 'cube_f8_f8'
 
193
LANGUAGE 'C' IMMUTABLE STRICT;
 
194
 
 
195
CREATE OR REPLACE FUNCTION cube(cube, float8) RETURNS cube
 
196
AS 'MODULE_PATHNAME', 'cube_c_f8'
 
197
LANGUAGE 'C' IMMUTABLE STRICT;
 
198
 
 
199
CREATE OR REPLACE FUNCTION cube(cube, float8, float8) RETURNS cube
 
200
AS 'MODULE_PATHNAME', 'cube_c_f8_f8'
 
201
LANGUAGE 'C' IMMUTABLE STRICT;
 
202
 
 
203
-- Test if cube is also a point
 
204
 
 
205
CREATE OR REPLACE FUNCTION cube_is_point(cube)
 
206
RETURNS bool
 
207
AS 'MODULE_PATHNAME'
 
208
LANGUAGE 'C' IMMUTABLE STRICT;
 
209
 
 
210
-- Increasing the size of a cube by a radius in at least n dimensions
 
211
 
 
212
CREATE OR REPLACE FUNCTION cube_enlarge(cube, float8, int4)
 
213
RETURNS cube
 
214
AS 'MODULE_PATHNAME'
 
215
LANGUAGE 'C' IMMUTABLE STRICT;
 
216
 
 
217
--
 
218
-- OPERATORS
 
219
--
 
220
 
 
221
CREATE OPERATOR < (
 
222
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_lt,
 
223
        COMMUTATOR = '>', NEGATOR = '>=',
 
224
        RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 
225
);
 
226
 
 
227
CREATE OPERATOR > (
 
228
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_gt,
 
229
        COMMUTATOR = '<', NEGATOR = '<=',
 
230
        RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 
231
);
 
232
 
 
233
CREATE OPERATOR <= (
 
234
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_le,
 
235
        COMMUTATOR = '>=', NEGATOR = '>',
 
236
        RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 
237
);
 
238
 
 
239
CREATE OPERATOR >= (
 
240
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_ge,
 
241
        COMMUTATOR = '<=', NEGATOR = '<',
 
242
        RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 
243
);
 
244
 
 
245
CREATE OPERATOR << (
 
246
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_left,
 
247
        COMMUTATOR = '>>',
 
248
        RESTRICT = positionsel, JOIN = positionjoinsel
 
249
);
 
250
 
 
251
CREATE OPERATOR &< (
 
252
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_over_left,
 
253
        COMMUTATOR = '&>',
 
254
        RESTRICT = positionsel, JOIN = positionjoinsel
 
255
);
 
256
 
 
257
CREATE OPERATOR && (
 
258
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_overlap,
 
259
        COMMUTATOR = '&&',
 
260
        RESTRICT = positionsel, JOIN = positionjoinsel
 
261
);
 
262
 
 
263
CREATE OPERATOR &> (
 
264
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_over_right,
 
265
        COMMUTATOR = '&<',
 
266
        RESTRICT = positionsel, JOIN = positionjoinsel
 
267
);
 
268
 
 
269
CREATE OPERATOR >> (
 
270
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_right,
 
271
        COMMUTATOR = '<<',
 
272
        RESTRICT = positionsel, JOIN = positionjoinsel
 
273
);
 
274
 
 
275
CREATE OPERATOR = (
 
276
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_eq,
 
277
        COMMUTATOR = '=', NEGATOR = '<>',
 
278
        RESTRICT = eqsel, JOIN = eqjoinsel,
 
279
        MERGES
 
280
);
 
281
 
 
282
CREATE OPERATOR <> (
 
283
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_ne,
 
284
        COMMUTATOR = '<>', NEGATOR = '=',
 
285
        RESTRICT = neqsel, JOIN = neqjoinsel
 
286
);
 
287
 
 
288
CREATE OPERATOR @ (
 
289
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_contains,
 
290
        COMMUTATOR = '~',
 
291
        RESTRICT = contsel, JOIN = contjoinsel
 
292
);
 
293
 
 
294
CREATE OPERATOR ~ (
 
295
        LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_contained,
 
296
        COMMUTATOR = '@',
 
297
        RESTRICT = contsel, JOIN = contjoinsel
 
298
);
 
299
 
 
300
 
 
301
-- define the GiST support methods
 
302
CREATE OR REPLACE FUNCTION g_cube_consistent(internal,cube,int4)
 
303
RETURNS bool
 
304
AS 'MODULE_PATHNAME'
 
305
LANGUAGE 'C';
 
306
 
 
307
CREATE OR REPLACE FUNCTION g_cube_compress(internal)
 
308
RETURNS internal 
 
309
AS 'MODULE_PATHNAME'
 
310
LANGUAGE 'C';
 
311
 
 
312
CREATE OR REPLACE FUNCTION g_cube_decompress(internal)
 
313
RETURNS internal 
 
314
AS 'MODULE_PATHNAME'
 
315
LANGUAGE 'C';
 
316
 
 
317
CREATE OR REPLACE FUNCTION g_cube_penalty(internal,internal,internal)
 
318
RETURNS internal
 
319
AS 'MODULE_PATHNAME'
 
320
LANGUAGE 'C' STRICT;
 
321
 
 
322
CREATE OR REPLACE FUNCTION g_cube_picksplit(internal, internal)
 
323
RETURNS internal
 
324
AS 'MODULE_PATHNAME'
 
325
LANGUAGE 'C';
 
326
 
 
327
CREATE OR REPLACE FUNCTION g_cube_union(internal, internal)
 
328
RETURNS cube 
 
329
AS 'MODULE_PATHNAME'
 
330
LANGUAGE 'C';
 
331
 
 
332
CREATE OR REPLACE FUNCTION g_cube_same(cube, cube, internal)
 
333
RETURNS internal 
 
334
AS 'MODULE_PATHNAME'
 
335
LANGUAGE 'C';
 
336
 
 
337
 
 
338
-- Create the operator classes for indexing
 
339
 
 
340
CREATE OPERATOR CLASS cube_ops
 
341
    DEFAULT FOR TYPE cube USING btree AS
 
342
        OPERATOR        1       < ,
 
343
        OPERATOR        2       <= ,
 
344
        OPERATOR        3       = ,
 
345
        OPERATOR        4       >= ,
 
346
        OPERATOR        5       > ,
 
347
        FUNCTION        1       cube_cmp(cube, cube);
 
348
 
 
349
CREATE OPERATOR CLASS gist_cube_ops
 
350
    DEFAULT FOR TYPE cube USING gist AS
 
351
        OPERATOR        1       << ,
 
352
        OPERATOR        2       &< ,
 
353
        OPERATOR        3       && ,
 
354
        OPERATOR        4       &> ,
 
355
        OPERATOR        5       >> ,
 
356
        OPERATOR        6       = ,
 
357
        OPERATOR        7       @ ,
 
358
        OPERATOR        8       ~ ,
 
359
        FUNCTION        1       g_cube_consistent (internal, cube, int4),
 
360
        FUNCTION        2       g_cube_union (internal, internal),
 
361
        FUNCTION        3       g_cube_compress (internal),
 
362
        FUNCTION        4       g_cube_decompress (internal),
 
363
        FUNCTION        5       g_cube_penalty (internal, internal, internal),
 
364
        FUNCTION        6       g_cube_picksplit (internal, internal),
 
365
        FUNCTION        7       g_cube_same (cube, cube, internal);