← Back to branch summary

~vcs-imports/mammoth-replicator/trunk

« back to all changes in this revision

Viewing changes to contrib/ltree/ltree.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/ltree/ltree.sql.in
 
1
-- Adjust this setting to control where the objects get created.
 
2
SET search_path = public;
 
3
 
 
4
CREATE FUNCTION ltree_in(cstring)
 
5
RETURNS ltree
 
6
AS 'MODULE_PATHNAME'
 
7
LANGUAGE 'C' WITH (isstrict);
 
8
 
 
9
CREATE FUNCTION ltree_out(ltree)
 
10
RETURNS cstring
 
11
AS 'MODULE_PATHNAME'
 
12
LANGUAGE 'C' WITH (isstrict);
 
13
 
 
14
CREATE TYPE ltree (
 
15
        INTERNALLENGTH = -1,
 
16
        INPUT = ltree_in,
 
17
        OUTPUT = ltree_out,
 
18
        STORAGE = extended
 
19
);
 
20
 
 
21
 
 
22
--Compare function for ltree
 
23
CREATE FUNCTION ltree_cmp(ltree,ltree)
 
24
RETURNS int4
 
25
AS 'MODULE_PATHNAME'
 
26
LANGUAGE 'C' WITH (isstrict,iscachable);
 
27
 
 
28
CREATE FUNCTION ltree_lt(ltree,ltree)
 
29
RETURNS bool
 
30
AS 'MODULE_PATHNAME'
 
31
LANGUAGE 'C' WITH (isstrict,iscachable);
 
32
 
 
33
CREATE FUNCTION ltree_le(ltree,ltree)
 
34
RETURNS bool
 
35
AS 'MODULE_PATHNAME'
 
36
LANGUAGE 'C' WITH (isstrict,iscachable);
 
37
 
 
38
CREATE FUNCTION ltree_eq(ltree,ltree)
 
39
RETURNS bool
 
40
AS 'MODULE_PATHNAME'
 
41
LANGUAGE 'C' WITH (isstrict,iscachable);
 
42
 
 
43
CREATE FUNCTION ltree_ge(ltree,ltree)
 
44
RETURNS bool
 
45
AS 'MODULE_PATHNAME'
 
46
LANGUAGE 'C' WITH (isstrict,iscachable);
 
47
 
 
48
CREATE FUNCTION ltree_gt(ltree,ltree)
 
49
RETURNS bool
 
50
AS 'MODULE_PATHNAME'
 
51
LANGUAGE 'C' WITH (isstrict,iscachable);
 
52
 
 
53
CREATE FUNCTION ltree_ne(ltree,ltree)
 
54
RETURNS bool
 
55
AS 'MODULE_PATHNAME'
 
56
LANGUAGE 'C' WITH (isstrict,iscachable);
 
57
 
 
58
 
 
59
CREATE OPERATOR < (
 
60
        LEFTARG = ltree,
 
61
        RIGHTARG = ltree,
 
62
        PROCEDURE = ltree_lt,
 
63
        COMMUTATOR = '>',
 
64
        NEGATOR = '>=',
 
65
        RESTRICT = contsel,
 
66
        JOIN = contjoinsel
 
67
);
 
68
 
 
69
CREATE OPERATOR <= (
 
70
        LEFTARG = ltree,
 
71
        RIGHTARG = ltree,
 
72
        PROCEDURE = ltree_le,
 
73
        COMMUTATOR = '>=',
 
74
        NEGATOR = '>',
 
75
        RESTRICT = contsel,
 
76
        JOIN = contjoinsel
 
77
);
 
78
 
 
79
CREATE OPERATOR >= (
 
80
        LEFTARG = ltree,
 
81
        RIGHTARG = ltree,
 
82
        PROCEDURE = ltree_ge,
 
83
        COMMUTATOR = '<=',
 
84
        NEGATOR = '<',
 
85
        RESTRICT = contsel,
 
86
        JOIN = contjoinsel
 
87
);
 
88
 
 
89
CREATE OPERATOR > (
 
90
        LEFTARG = ltree,
 
91
        RIGHTARG = ltree,
 
92
        PROCEDURE = ltree_gt,
 
93
        COMMUTATOR = '<',
 
94
        NEGATOR = '<=',
 
95
        RESTRICT = contsel,
 
96
        JOIN = contjoinsel
 
97
);
 
98
 
 
99
CREATE OPERATOR = (
 
100
        LEFTARG = ltree,
 
101
        RIGHTARG = ltree,
 
102
        PROCEDURE = ltree_eq,
 
103
        COMMUTATOR = '=',
 
104
        NEGATOR = '<>',
 
105
        RESTRICT = eqsel,
 
106
        JOIN = eqjoinsel,
 
107
        SORT1 = '<',
 
108
        SORT2 = '<'
 
109
);
 
110
 
 
111
CREATE OPERATOR <> (
 
112
        LEFTARG = ltree,
 
113
        RIGHTARG = ltree,
 
114
        PROCEDURE = ltree_ne,
 
115
        COMMUTATOR = '<>',
 
116
        NEGATOR = '=',
 
117
        RESTRICT = neqsel,
 
118
        JOIN = neqjoinsel
 
119
);
 
120
 
 
121
--util functions
 
122
 
 
123
CREATE FUNCTION subltree(ltree,int4,int4)
 
124
RETURNS ltree
 
125
AS 'MODULE_PATHNAME'
 
126
LANGUAGE 'C' WITH (isstrict,iscachable);
 
127
 
 
128
CREATE FUNCTION subpath(ltree,int4,int4)
 
129
RETURNS ltree
 
130
AS 'MODULE_PATHNAME'
 
131
LANGUAGE 'C' WITH (isstrict,iscachable);
 
132
 
 
133
CREATE FUNCTION subpath(ltree,int4)
 
134
RETURNS ltree
 
135
AS 'MODULE_PATHNAME'
 
136
LANGUAGE 'C' WITH (isstrict,iscachable);
 
137
 
 
138
CREATE FUNCTION index(ltree,ltree)
 
139
RETURNS int4
 
140
AS 'MODULE_PATHNAME', 'ltree_index'
 
141
LANGUAGE 'C' WITH (isstrict,iscachable);
 
142
 
 
143
CREATE FUNCTION index(ltree,ltree,int4)
 
144
RETURNS int4
 
145
AS 'MODULE_PATHNAME', 'ltree_index'
 
146
LANGUAGE 'C' WITH (isstrict,iscachable);
 
147
 
 
148
CREATE FUNCTION nlevel(ltree)
 
149
RETURNS int4
 
150
AS 'MODULE_PATHNAME'
 
151
LANGUAGE 'C' WITH (isstrict,iscachable);
 
152
 
 
153
CREATE FUNCTION ltree2text(ltree)
 
154
RETURNS text
 
155
AS 'MODULE_PATHNAME'
 
156
LANGUAGE 'C' WITH (isstrict,iscachable);
 
157
 
 
158
CREATE FUNCTION text2ltree(text)
 
159
RETURNS ltree
 
160
AS 'MODULE_PATHNAME'
 
161
LANGUAGE 'C' WITH (isstrict,iscachable);
 
162
 
 
163
CREATE FUNCTION lca(_ltree)
 
164
RETURNS ltree
 
165
AS 'MODULE_PATHNAME','_lca'
 
166
LANGUAGE 'C' WITH (isstrict,iscachable);
 
167
 
 
168
CREATE FUNCTION lca(ltree,ltree)
 
169
RETURNS ltree
 
170
AS 'MODULE_PATHNAME'
 
171
LANGUAGE 'C' WITH (isstrict,iscachable);
 
172
 
 
173
CREATE FUNCTION lca(ltree,ltree,ltree)
 
174
RETURNS ltree
 
175
AS 'MODULE_PATHNAME'
 
176
LANGUAGE 'C' WITH (isstrict,iscachable);
 
177
 
 
178
CREATE FUNCTION lca(ltree,ltree,ltree,ltree)
 
179
RETURNS ltree
 
180
AS 'MODULE_PATHNAME'
 
181
LANGUAGE 'C' WITH (isstrict,iscachable);
 
182
 
 
183
CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree)
 
184
RETURNS ltree
 
185
AS 'MODULE_PATHNAME'
 
186
LANGUAGE 'C' WITH (isstrict,iscachable);
 
187
 
 
188
CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree)
 
189
RETURNS ltree
 
190
AS 'MODULE_PATHNAME'
 
191
LANGUAGE 'C' WITH (isstrict,iscachable);
 
192
 
 
193
CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree,ltree)
 
194
RETURNS ltree
 
195
AS 'MODULE_PATHNAME'
 
196
LANGUAGE 'C' WITH (isstrict,iscachable);
 
197
 
 
198
CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree,ltree,ltree)
 
199
RETURNS ltree
 
200
AS 'MODULE_PATHNAME'
 
201
LANGUAGE 'C' WITH (isstrict,iscachable);
 
202
 
 
203
CREATE FUNCTION ltree_isparent(ltree,ltree)
 
204
RETURNS bool
 
205
AS 'MODULE_PATHNAME'
 
206
LANGUAGE 'C' WITH (isstrict,iscachable);
 
207
 
 
208
CREATE FUNCTION ltree_risparent(ltree,ltree)
 
209
RETURNS bool
 
210
AS 'MODULE_PATHNAME'
 
211
LANGUAGE 'C' WITH (isstrict,iscachable);
 
212
 
 
213
CREATE FUNCTION ltree_addltree(ltree,ltree)
 
214
RETURNS ltree
 
215
AS 'MODULE_PATHNAME'
 
216
LANGUAGE 'C' WITH (isstrict,iscachable);
 
217
 
 
218
CREATE FUNCTION ltree_addtext(ltree,text)
 
219
RETURNS ltree
 
220
AS 'MODULE_PATHNAME'
 
221
LANGUAGE 'C' WITH (isstrict,iscachable);
 
222
 
 
223
CREATE FUNCTION ltree_textadd(text,ltree)
 
224
RETURNS ltree
 
225
AS 'MODULE_PATHNAME'
 
226
LANGUAGE 'C' WITH (isstrict,iscachable);
 
227
 
 
228
CREATE OPERATOR @> (
 
229
        LEFTARG = ltree,
 
230
        RIGHTARG = ltree,
 
231
        PROCEDURE = ltree_isparent,
 
232
        COMMUTATOR = '<@',
 
233
        RESTRICT = contsel,
 
234
        JOIN = contjoinsel
 
235
);
 
236
 
 
237
CREATE OPERATOR ^@> (
 
238
        LEFTARG = ltree,
 
239
        RIGHTARG = ltree,
 
240
        PROCEDURE = ltree_isparent,
 
241
        COMMUTATOR = '^<@',
 
242
        RESTRICT = contsel,
 
243
        JOIN = contjoinsel
 
244
);
 
245
 
 
246
CREATE OPERATOR <@ (
 
247
        LEFTARG = ltree,
 
248
        RIGHTARG = ltree,
 
249
        PROCEDURE = ltree_risparent,
 
250
        COMMUTATOR = '@>',
 
251
        RESTRICT = contsel,
 
252
        JOIN = contjoinsel
 
253
);
 
254
 
 
255
CREATE OPERATOR ^<@ (
 
256
        LEFTARG = ltree,
 
257
        RIGHTARG = ltree,
 
258
        PROCEDURE = ltree_risparent,
 
259
        COMMUTATOR = '^@>',
 
260
        RESTRICT = contsel,
 
261
        JOIN = contjoinsel
 
262
);
 
263
 
 
264
CREATE OPERATOR || (
 
265
        LEFTARG = ltree,
 
266
        RIGHTARG = ltree,
 
267
        PROCEDURE = ltree_addltree
 
268
);
 
269
 
 
270
CREATE OPERATOR || (
 
271
        LEFTARG = ltree,
 
272
        RIGHTARG = text,
 
273
        PROCEDURE = ltree_addtext
 
274
);
 
275
 
 
276
CREATE OPERATOR || (
 
277
        LEFTARG = text,
 
278
        RIGHTARG = ltree,
 
279
        PROCEDURE = ltree_textadd
 
280
);
 
281
 
 
282
 
 
283
-- B-tree support
 
284
 
 
285
CREATE OPERATOR CLASS ltree_ops
 
286
    DEFAULT FOR TYPE ltree USING btree AS
 
287
        OPERATOR        1       < ,
 
288
        OPERATOR        2       <= ,
 
289
        OPERATOR        3       = ,
 
290
        OPERATOR        4       >= ,
 
291
        OPERATOR        5       > ,
 
292
        FUNCTION        1       ltree_cmp(ltree, ltree);
 
293
 
 
294
 
 
295
--lquery type
 
296
CREATE FUNCTION lquery_in(cstring)
 
297
RETURNS lquery
 
298
AS 'MODULE_PATHNAME'
 
299
LANGUAGE 'C' WITH (isstrict);
 
300
 
 
301
CREATE FUNCTION lquery_out(lquery)
 
302
RETURNS cstring
 
303
AS 'MODULE_PATHNAME'
 
304
LANGUAGE 'C' WITH (isstrict);
 
305
 
 
306
CREATE TYPE lquery (
 
307
        INTERNALLENGTH = -1,
 
308
        INPUT = lquery_in,
 
309
        OUTPUT = lquery_out,
 
310
        STORAGE = extended
 
311
);
 
312
 
 
313
CREATE FUNCTION ltq_regex(ltree,lquery)
 
314
RETURNS bool
 
315
AS 'MODULE_PATHNAME'
 
316
LANGUAGE 'C' WITH (isstrict,iscachable);
 
317
 
 
318
CREATE FUNCTION ltq_rregex(lquery,ltree)
 
319
RETURNS bool
 
320
AS 'MODULE_PATHNAME'
 
321
LANGUAGE 'C' WITH (isstrict,iscachable);
 
322
 
 
323
CREATE OPERATOR ~ (
 
324
        LEFTARG = ltree,
 
325
        RIGHTARG = lquery,
 
326
        PROCEDURE = ltq_regex,
 
327
        COMMUTATOR = '~',
 
328
        RESTRICT = contsel,
 
329
        JOIN = contjoinsel
 
330
);
 
331
 
 
332
CREATE OPERATOR ~ (
 
333
        LEFTARG = lquery,
 
334
        RIGHTARG = ltree,
 
335
        PROCEDURE = ltq_rregex,
 
336
        COMMUTATOR = '~',
 
337
        RESTRICT = contsel,
 
338
        JOIN = contjoinsel
 
339
);
 
340
 
 
341
--not-indexed
 
342
CREATE OPERATOR ^~ (
 
343
        LEFTARG = ltree,
 
344
        RIGHTARG = lquery,
 
345
        PROCEDURE = ltq_regex,
 
346
        COMMUTATOR = '^~',
 
347
        RESTRICT = contsel,
 
348
        JOIN = contjoinsel
 
349
);
 
350
 
 
351
CREATE OPERATOR ^~ (
 
352
        LEFTARG = lquery,
 
353
        RIGHTARG = ltree,
 
354
        PROCEDURE = ltq_rregex,
 
355
        COMMUTATOR = '^~',
 
356
        RESTRICT = contsel,
 
357
        JOIN = contjoinsel
 
358
);
 
359
 
 
360
CREATE FUNCTION lt_q_regex(ltree,_lquery)
 
361
RETURNS bool
 
362
AS 'MODULE_PATHNAME'
 
363
LANGUAGE 'C' WITH (isstrict,iscachable);
 
364
 
 
365
CREATE FUNCTION lt_q_rregex(_lquery,ltree)
 
366
RETURNS bool
 
367
AS 'MODULE_PATHNAME'
 
368
LANGUAGE 'C' WITH (isstrict,iscachable);
 
369
 
 
370
CREATE OPERATOR ? (
 
371
        LEFTARG = ltree,
 
372
        RIGHTARG = _lquery,
 
373
        PROCEDURE = lt_q_regex,
 
374
        COMMUTATOR = '?',
 
375
        RESTRICT = contsel,
 
376
        JOIN = contjoinsel
 
377
);
 
378
 
 
379
CREATE OPERATOR ? (
 
380
        LEFTARG = _lquery,
 
381
        RIGHTARG = ltree,
 
382
        PROCEDURE = lt_q_rregex,
 
383
        COMMUTATOR = '?',
 
384
        RESTRICT = contsel,
 
385
        JOIN = contjoinsel
 
386
);
 
387
 
 
388
--not-indexed
 
389
CREATE OPERATOR ^? (
 
390
        LEFTARG = ltree,
 
391
        RIGHTARG = _lquery,
 
392
        PROCEDURE = lt_q_regex,
 
393
        COMMUTATOR = '^?',
 
394
        RESTRICT = contsel,
 
395
        JOIN = contjoinsel
 
396
);
 
397
 
 
398
CREATE OPERATOR ^? (
 
399
        LEFTARG = _lquery,
 
400
        RIGHTARG = ltree,
 
401
        PROCEDURE = lt_q_rregex,
 
402
        COMMUTATOR = '^?',
 
403
        RESTRICT = contsel,
 
404
        JOIN = contjoinsel
 
405
);
 
406
 
 
407
CREATE FUNCTION ltxtq_in(cstring)
 
408
RETURNS ltxtquery
 
409
AS 'MODULE_PATHNAME'
 
410
LANGUAGE 'C' WITH (isstrict);
 
411
 
 
412
CREATE FUNCTION ltxtq_out(ltxtquery)
 
413
RETURNS cstring
 
414
AS 'MODULE_PATHNAME'
 
415
LANGUAGE 'C' WITH (isstrict);
 
416
 
 
417
CREATE TYPE ltxtquery (
 
418
        INTERNALLENGTH = -1,
 
419
        INPUT = ltxtq_in,
 
420
        OUTPUT = ltxtq_out,
 
421
        STORAGE = extended
 
422
);
 
423
 
 
424
-- operations WITH ltxtquery
 
425
 
 
426
CREATE FUNCTION ltxtq_exec(ltree, ltxtquery)
 
427
RETURNS bool
 
428
AS 'MODULE_PATHNAME'
 
429
LANGUAGE 'C' WITH (isstrict, iscachable);
 
430
 
 
431
CREATE FUNCTION ltxtq_rexec(ltxtquery, ltree)
 
432
RETURNS bool
 
433
AS 'MODULE_PATHNAME'
 
434
LANGUAGE 'C' WITH (isstrict, iscachable);
 
435
 
 
436
CREATE OPERATOR @ (
 
437
        LEFTARG = ltree,
 
438
        RIGHTARG = ltxtquery,
 
439
        PROCEDURE = ltxtq_exec,
 
440
        COMMUTATOR = '@',
 
441
        RESTRICT = contsel,
 
442
        JOIN = contjoinsel
 
443
);
 
444
 
 
445
CREATE OPERATOR @ (
 
446
        LEFTARG = ltxtquery,
 
447
        RIGHTARG = ltree,
 
448
        PROCEDURE = ltxtq_rexec,
 
449
        COMMUTATOR = '@',
 
450
        RESTRICT = contsel,
 
451
        JOIN = contjoinsel
 
452
);
 
453
 
 
454
--not-indexed
 
455
CREATE OPERATOR ^@ (
 
456
        LEFTARG = ltree,
 
457
        RIGHTARG = ltxtquery,
 
458
        PROCEDURE = ltxtq_exec,
 
459
        COMMUTATOR = '^@',
 
460
        RESTRICT = contsel,
 
461
        JOIN = contjoinsel
 
462
);
 
463
 
 
464
CREATE OPERATOR ^@ (
 
465
        LEFTARG = ltxtquery,
 
466
        RIGHTARG = ltree,
 
467
        PROCEDURE = ltxtq_rexec,
 
468
        COMMUTATOR = '^@',
 
469
        RESTRICT = contsel,
 
470
        JOIN = contjoinsel
 
471
);
 
472
 
 
473
--GiST support for ltree
 
474
CREATE FUNCTION ltree_gist_in(cstring)
 
475
RETURNS ltree_gist
 
476
AS 'MODULE_PATHNAME'
 
477
LANGUAGE 'C' WITH (isstrict);
 
478
  
 
479
CREATE FUNCTION ltree_gist_out(ltree_gist)
 
480
RETURNS cstring
 
481
AS 'MODULE_PATHNAME'
 
482
LANGUAGE 'C' WITH (isstrict);
 
483
  
 
484
CREATE TYPE ltree_gist (
 
485
        internallength = -1,
 
486
        input = ltree_gist_in,
 
487
        output = ltree_gist_out,
 
488
        storage = plain
 
489
);   
 
490
 
 
491
 
 
492
CREATE FUNCTION ltree_consistent(internal,internal,int2)
 
493
RETURNS bool as 'MODULE_PATHNAME' language 'C';
 
494
CREATE FUNCTION ltree_compress(internal)
 
495
RETURNS internal as 'MODULE_PATHNAME' language 'C';
 
496
CREATE FUNCTION ltree_decompress(internal)
 
497
RETURNS internal as 'MODULE_PATHNAME' language 'C';
 
498
CREATE FUNCTION ltree_penalty(internal,internal,internal)
 
499
RETURNS internal as 'MODULE_PATHNAME' language 'C' with(isstrict);
 
500
CREATE FUNCTION ltree_picksplit(internal, internal)
 
501
RETURNS internal as 'MODULE_PATHNAME' language 'C';
 
502
CREATE FUNCTION ltree_union(internal, internal)
 
503
RETURNS int4 as 'MODULE_PATHNAME' language 'C';
 
504
CREATE FUNCTION ltree_same(internal, internal, internal)
 
505
RETURNS internal as 'MODULE_PATHNAME' language 'C';
 
506
 
 
507
CREATE OPERATOR CLASS gist_ltree_ops
 
508
    DEFAULT FOR TYPE ltree USING gist AS
 
509
        OPERATOR        1       < ,
 
510
        OPERATOR        2       <= ,
 
511
        OPERATOR        3       = ,
 
512
        OPERATOR        4       >= ,
 
513
        OPERATOR        5       > ,
 
514
        OPERATOR        10      @> ,
 
515
        OPERATOR        11      <@ ,
 
516
        OPERATOR        12      ~ (ltree, lquery) ,
 
517
        OPERATOR        13      ~ (lquery, ltree) ,
 
518
        OPERATOR        14      @ (ltree, ltxtquery) ,
 
519
        OPERATOR        15      @ (ltxtquery, ltree) ,
 
520
        OPERATOR        16      ? (ltree, _lquery) ,
 
521
        OPERATOR        17      ? (_lquery, ltree) ,
 
522
        FUNCTION        1       ltree_consistent (internal, internal, int2),
 
523
        FUNCTION        2       ltree_union (internal, internal),
 
524
        FUNCTION        3       ltree_compress (internal),
 
525
        FUNCTION        4       ltree_decompress (internal),
 
526
        FUNCTION        5       ltree_penalty (internal, internal, internal),
 
527
        FUNCTION        6       ltree_picksplit (internal, internal),
 
528
        FUNCTION        7       ltree_same (internal, internal, internal),
 
529
        STORAGE         ltree_gist;
 
530
 
 
531
 
 
532
-- arrays of ltree
 
533
 
 
534
CREATE FUNCTION _ltree_isparent(_ltree,ltree)
 
535
RETURNS bool
 
536
AS 'MODULE_PATHNAME'
 
537
LANGUAGE 'C' WITH (isstrict,iscachable);
 
538
 
 
539
CREATE FUNCTION _ltree_r_isparent(ltree,_ltree)
 
540
RETURNS bool
 
541
AS 'MODULE_PATHNAME'
 
542
LANGUAGE 'C' WITH (isstrict,iscachable);
 
543
 
 
544
CREATE FUNCTION _ltree_risparent(_ltree,ltree)
 
545
RETURNS bool
 
546
AS 'MODULE_PATHNAME'
 
547
LANGUAGE 'C' WITH (isstrict,iscachable);
 
548
 
 
549
CREATE FUNCTION _ltree_r_risparent(ltree,_ltree)
 
550
RETURNS bool
 
551
AS 'MODULE_PATHNAME'
 
552
LANGUAGE 'C' WITH (isstrict,iscachable);
 
553
 
 
554
CREATE FUNCTION _ltq_regex(_ltree,lquery)
 
555
RETURNS bool
 
556
AS 'MODULE_PATHNAME'
 
557
LANGUAGE 'C' WITH (isstrict,iscachable);
 
558
 
 
559
CREATE FUNCTION _ltq_rregex(lquery,_ltree)
 
560
RETURNS bool
 
561
AS 'MODULE_PATHNAME'
 
562
LANGUAGE 'C' WITH (isstrict,iscachable);
 
563
 
 
564
CREATE FUNCTION _lt_q_regex(_ltree,_lquery)
 
565
RETURNS bool
 
566
AS 'MODULE_PATHNAME'
 
567
LANGUAGE 'C' WITH (isstrict,iscachable);
 
568
 
 
569
CREATE FUNCTION _lt_q_rregex(_lquery,_ltree)
 
570
RETURNS bool
 
571
AS 'MODULE_PATHNAME'
 
572
LANGUAGE 'C' WITH (isstrict,iscachable);
 
573
 
 
574
CREATE FUNCTION _ltxtq_exec(_ltree, ltxtquery)
 
575
RETURNS bool
 
576
AS 'MODULE_PATHNAME'
 
577
LANGUAGE 'C' WITH (isstrict, iscachable);
 
578
 
 
579
CREATE FUNCTION _ltxtq_rexec(ltxtquery, _ltree)
 
580
RETURNS bool
 
581
AS 'MODULE_PATHNAME'
 
582
LANGUAGE 'C' WITH (isstrict, iscachable);
 
583
 
 
584
CREATE OPERATOR @> (
 
585
        LEFTARG = _ltree,
 
586
        RIGHTARG = ltree,
 
587
        PROCEDURE = _ltree_isparent,
 
588
        COMMUTATOR = '<@',
 
589
        RESTRICT = contsel,
 
590
        JOIN = contjoinsel
 
591
);
 
592
 
 
593
CREATE OPERATOR <@ (
 
594
        LEFTARG = ltree,
 
595
        RIGHTARG = _ltree,
 
596
        PROCEDURE = _ltree_r_isparent,
 
597
        COMMUTATOR = '@>',
 
598
        RESTRICT = contsel,
 
599
        JOIN = contjoinsel
 
600
);
 
601
 
 
602
CREATE OPERATOR <@ (
 
603
        LEFTARG = _ltree,
 
604
        RIGHTARG = ltree,
 
605
        PROCEDURE = _ltree_risparent,
 
606
        COMMUTATOR = '@>',
 
607
        RESTRICT = contsel,
 
608
        JOIN = contjoinsel
 
609
);
 
610
 
 
611
CREATE OPERATOR @> (
 
612
        LEFTARG = ltree,
 
613
        RIGHTARG = _ltree,
 
614
        PROCEDURE = _ltree_r_risparent,
 
615
        COMMUTATOR = '<@',
 
616
        RESTRICT = contsel,
 
617
        JOIN = contjoinsel
 
618
);
 
619
 
 
620
CREATE OPERATOR ~ (
 
621
        LEFTARG = _ltree,
 
622
        RIGHTARG = lquery,
 
623
        PROCEDURE = _ltq_regex,
 
624
        COMMUTATOR = '~',
 
625
        RESTRICT = contsel,
 
626
        JOIN = contjoinsel
 
627
);
 
628
 
 
629
CREATE OPERATOR ~ (
 
630
        LEFTARG = lquery,
 
631
        RIGHTARG = _ltree,
 
632
        PROCEDURE = _ltq_rregex,
 
633
        COMMUTATOR = '~',
 
634
        RESTRICT = contsel,
 
635
        JOIN = contjoinsel
 
636
);
 
637
 
 
638
CREATE OPERATOR ? (
 
639
        LEFTARG = _ltree,
 
640
        RIGHTARG = _lquery,
 
641
        PROCEDURE = _lt_q_regex,
 
642
        COMMUTATOR = '?',
 
643
        RESTRICT = contsel,
 
644
        JOIN = contjoinsel
 
645
);
 
646
 
 
647
CREATE OPERATOR ? (
 
648
        LEFTARG = _lquery,
 
649
        RIGHTARG = _ltree,
 
650
        PROCEDURE = _lt_q_rregex,
 
651
        COMMUTATOR = '?',
 
652
        RESTRICT = contsel,
 
653
        JOIN = contjoinsel
 
654
);
 
655
 
 
656
CREATE OPERATOR @ (
 
657
        LEFTARG = _ltree,
 
658
        RIGHTARG = ltxtquery,
 
659
        PROCEDURE = _ltxtq_exec,
 
660
        COMMUTATOR = '@',
 
661
        RESTRICT = contsel,
 
662
        JOIN = contjoinsel
 
663
);
 
664
 
 
665
CREATE OPERATOR @ (
 
666
        LEFTARG = ltxtquery,
 
667
        RIGHTARG = _ltree,
 
668
        PROCEDURE = _ltxtq_rexec,
 
669
        COMMUTATOR = '@',
 
670
        RESTRICT = contsel,
 
671
        JOIN = contjoinsel
 
672
);
 
673
 
 
674
 
 
675
--not indexed
 
676
CREATE OPERATOR ^@> (
 
677
        LEFTARG = _ltree,
 
678
        RIGHTARG = ltree,
 
679
        PROCEDURE = _ltree_isparent,
 
680
        COMMUTATOR = '^<@',
 
681
        RESTRICT = contsel,
 
682
        JOIN = contjoinsel
 
683
);
 
684
 
 
685
CREATE OPERATOR ^<@ (
 
686
        LEFTARG = ltree,
 
687
        RIGHTARG = _ltree,
 
688
        PROCEDURE = _ltree_r_isparent,
 
689
        COMMUTATOR = '^@>',
 
690
        RESTRICT = contsel,
 
691
        JOIN = contjoinsel
 
692
);
 
693
 
 
694
CREATE OPERATOR ^<@ (
 
695
        LEFTARG = _ltree,
 
696
        RIGHTARG = ltree,
 
697
        PROCEDURE = _ltree_risparent,
 
698
        COMMUTATOR = '^@>',
 
699
        RESTRICT = contsel,
 
700
        JOIN = contjoinsel
 
701
);
 
702
 
 
703
CREATE OPERATOR ^@> (
 
704
        LEFTARG = ltree,
 
705
        RIGHTARG = _ltree,
 
706
        PROCEDURE = _ltree_r_risparent,
 
707
        COMMUTATOR = '^<@',
 
708
        RESTRICT = contsel,
 
709
        JOIN = contjoinsel
 
710
);
 
711
 
 
712
CREATE OPERATOR ^~ (
 
713
        LEFTARG = _ltree,
 
714
        RIGHTARG = lquery,
 
715
        PROCEDURE = _ltq_regex,
 
716
        COMMUTATOR = '^~',
 
717
        RESTRICT = contsel,
 
718
        JOIN = contjoinsel
 
719
);
 
720
 
 
721
CREATE OPERATOR ^~ (
 
722
        LEFTARG = lquery,
 
723
        RIGHTARG = _ltree,
 
724
        PROCEDURE = _ltq_rregex,
 
725
        COMMUTATOR = '^~',
 
726
        RESTRICT = contsel,
 
727
        JOIN = contjoinsel
 
728
);
 
729
 
 
730
CREATE OPERATOR ^? (
 
731
        LEFTARG = _ltree,
 
732
        RIGHTARG = _lquery,
 
733
        PROCEDURE = _lt_q_regex,
 
734
        COMMUTATOR = '^?',
 
735
        RESTRICT = contsel,
 
736
        JOIN = contjoinsel
 
737
);
 
738
 
 
739
CREATE OPERATOR ^? (
 
740
        LEFTARG = _lquery,
 
741
        RIGHTARG = _ltree,
 
742
        PROCEDURE = _lt_q_rregex,
 
743
        COMMUTATOR = '^?',
 
744
        RESTRICT = contsel,
 
745
        JOIN = contjoinsel
 
746
);
 
747
 
 
748
CREATE OPERATOR ^@ (
 
749
        LEFTARG = _ltree,
 
750
        RIGHTARG = ltxtquery,
 
751
        PROCEDURE = _ltxtq_exec,
 
752
        COMMUTATOR = '^@',
 
753
        RESTRICT = contsel,
 
754
        JOIN = contjoinsel
 
755
);
 
756
 
 
757
CREATE OPERATOR ^@ (
 
758
        LEFTARG = ltxtquery,
 
759
        RIGHTARG = _ltree,
 
760
        PROCEDURE = _ltxtq_rexec,
 
761
        COMMUTATOR = '^@',
 
762
        RESTRICT = contsel,
 
763
        JOIN = contjoinsel
 
764
);
 
765
 
 
766
--extractors
 
767
CREATE FUNCTION _ltree_extract_isparent(_ltree,ltree)
 
768
RETURNS ltree
 
769
AS 'MODULE_PATHNAME'
 
770
LANGUAGE 'C' WITH (isstrict,iscachable);
 
771
 
 
772
CREATE OPERATOR ?@> (
 
773
        LEFTARG = _ltree,
 
774
        RIGHTARG = ltree,
 
775
        PROCEDURE = _ltree_extract_isparent
 
776
);
 
777
 
 
778
CREATE FUNCTION _ltree_extract_risparent(_ltree,ltree)
 
779
RETURNS ltree
 
780
AS 'MODULE_PATHNAME'
 
781
LANGUAGE 'C' WITH (isstrict,iscachable);
 
782
 
 
783
CREATE OPERATOR ?<@ (
 
784
        LEFTARG = _ltree,
 
785
        RIGHTARG = ltree,
 
786
        PROCEDURE = _ltree_extract_risparent
 
787
);
 
788
 
 
789
CREATE FUNCTION _ltq_extract_regex(_ltree,lquery)
 
790
RETURNS ltree
 
791
AS 'MODULE_PATHNAME'
 
792
LANGUAGE 'C' WITH (isstrict,iscachable);
 
793
 
 
794
CREATE OPERATOR ?~ (
 
795
        LEFTARG = _ltree,
 
796
        RIGHTARG = lquery,
 
797
        PROCEDURE = _ltq_extract_regex
 
798
);
 
799
 
 
800
CREATE FUNCTION _ltxtq_extract_exec(_ltree,ltxtquery)
 
801
RETURNS ltree
 
802
AS 'MODULE_PATHNAME'
 
803
LANGUAGE 'C' WITH (isstrict,iscachable);
 
804
 
 
805
CREATE OPERATOR ?@ (
 
806
        LEFTARG = _ltree,
 
807
        RIGHTARG = ltxtquery,
 
808
        PROCEDURE = _ltxtq_extract_exec
 
809
);
 
810
 
 
811
--GiST support for ltree[]
 
812
CREATE FUNCTION _ltree_consistent(internal,internal,int2)
 
813
RETURNS bool
 
814
AS 'MODULE_PATHNAME'
 
815
LANGUAGE 'C';
 
816
CREATE FUNCTION _ltree_compress(internal)
 
817
RETURNS internal
 
818
AS 'MODULE_PATHNAME'
 
819
LANGUAGE 'C';
 
820
CREATE FUNCTION _ltree_penalty(internal,internal,internal)
 
821
RETURNS internal
 
822
AS 'MODULE_PATHNAME'
 
823
LANGUAGE 'C' WITH(isstrict);
 
824
CREATE FUNCTION _ltree_picksplit(internal, internal)
 
825
RETURNS internal
 
826
AS 'MODULE_PATHNAME'
 
827
LANGUAGE 'C';
 
828
CREATE FUNCTION _ltree_union(internal, internal)
 
829
RETURNS int4
 
830
AS 'MODULE_PATHNAME'
 
831
LANGUAGE 'C';
 
832
CREATE FUNCTION _ltree_same(internal, internal, internal)
 
833
RETURNS internal
 
834
AS 'MODULE_PATHNAME'
 
835
LANGUAGE 'C';
 
836
 
 
837
CREATE OPERATOR CLASS gist__ltree_ops
 
838
    DEFAULT FOR TYPE _ltree USING gist AS
 
839
        OPERATOR        10      <@ (_ltree, ltree)      RECHECK ,
 
840
        OPERATOR        11      @> (ltree, _ltree)      RECHECK ,
 
841
        OPERATOR        12      ~ (_ltree, lquery)      RECHECK ,
 
842
        OPERATOR        13      ~ (lquery, _ltree)      RECHECK ,
 
843
        OPERATOR        14      @ (_ltree, ltxtquery)   RECHECK ,
 
844
        OPERATOR        15      @ (ltxtquery, _ltree)   RECHECK ,
 
845
        OPERATOR        16      ? (_ltree, _lquery)     RECHECK ,
 
846
        OPERATOR        17      ? (_lquery, _ltree)     RECHECK ,
 
847
        FUNCTION        1       _ltree_consistent (internal, internal, int2),
 
848
        FUNCTION        2       _ltree_union (internal, internal),
 
849
        FUNCTION        3       _ltree_compress (internal),
 
850
        FUNCTION        4       ltree_decompress (internal),
 
851
        FUNCTION        5       _ltree_penalty (internal, internal, internal),
 
852
        FUNCTION        6       _ltree_picksplit (internal, internal),
 
853
        FUNCTION        7       _ltree_same (internal, internal, internal),
 
854
        STORAGE         ltree_gist;