← Back to branch summary

~vcs-imports/mammoth-replicator/trunk

« back to all changes in this revision

Viewing changes to contrib/btree_gist/btree_gist.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/btree_gist/btree_gist.sql.in
 
1
-- Adjust this setting to control where the objects get created.
 
2
SET search_path = public;
 
3
 
 
4
CREATE FUNCTION gbtreekey4_in(cstring)
 
5
RETURNS gbtreekey4
 
6
AS 'MODULE_PATHNAME', 'gbtreekey_in'
 
7
LANGUAGE 'c' WITH (isstrict);
 
8
 
 
9
CREATE FUNCTION gbtreekey4_out(gbtreekey4)
 
10
RETURNS cstring
 
11
AS 'MODULE_PATHNAME', 'gbtreekey_out'
 
12
LANGUAGE 'c' WITH (isstrict);
 
13
 
 
14
CREATE TYPE gbtreekey4 (
 
15
INTERNALLENGTH = 4,
 
16
INPUT  = gbtreekey4_in,
 
17
OUTPUT = gbtreekey4_out
 
18
);
 
19
 
 
20
CREATE FUNCTION gbtreekey8_in(cstring)
 
21
RETURNS gbtreekey8
 
22
AS 'MODULE_PATHNAME', 'gbtreekey_in'
 
23
LANGUAGE 'c' WITH (isstrict);
 
24
 
 
25
CREATE FUNCTION gbtreekey8_out(gbtreekey8)
 
26
RETURNS cstring
 
27
AS 'MODULE_PATHNAME', 'gbtreekey_out'
 
28
LANGUAGE 'c' WITH (isstrict);
 
29
 
 
30
CREATE TYPE gbtreekey8 (
 
31
INTERNALLENGTH = 8,
 
32
INPUT  = gbtreekey8_in,
 
33
OUTPUT = gbtreekey8_out
 
34
);
 
35
 
 
36
CREATE FUNCTION gbtreekey16_in(cstring)
 
37
RETURNS gbtreekey16
 
38
AS 'MODULE_PATHNAME', 'gbtreekey_in'
 
39
LANGUAGE 'c' WITH (isstrict);
 
40
 
 
41
CREATE FUNCTION gbtreekey16_out(gbtreekey16)
 
42
RETURNS cstring
 
43
AS 'MODULE_PATHNAME', 'gbtreekey_out'
 
44
LANGUAGE 'c' WITH (isstrict);
 
45
 
 
46
CREATE TYPE gbtreekey16 (
 
47
INTERNALLENGTH = 16,
 
48
INPUT  = gbtreekey16_in,
 
49
OUTPUT = gbtreekey16_out
 
50
);
 
51
 
 
52
CREATE FUNCTION gbtreekey24_in(cstring)
 
53
RETURNS gbtreekey24
 
54
AS 'MODULE_PATHNAME', 'gbtreekey_in'
 
55
LANGUAGE 'c' WITH (isstrict);
 
56
 
 
57
CREATE FUNCTION gbtreekey24_out(gbtreekey24)
 
58
RETURNS cstring
 
59
AS 'MODULE_PATHNAME', 'gbtreekey_out'
 
60
LANGUAGE 'c' WITH (isstrict);
 
61
 
 
62
CREATE TYPE gbtreekey24 (
 
63
INTERNALLENGTH = 24,
 
64
INPUT  = gbtreekey24_in,
 
65
OUTPUT = gbtreekey24_out
 
66
);
 
67
 
 
68
CREATE FUNCTION gbtreekey_var_in(cstring)
 
69
RETURNS gbtreekey_var
 
70
AS 'MODULE_PATHNAME', 'gbtreekey_in'
 
71
LANGUAGE 'c' WITH (isstrict);
 
72
 
 
73
CREATE FUNCTION gbtreekey_var_out(gbtreekey_var)
 
74
RETURNS cstring
 
75
AS 'MODULE_PATHNAME', 'gbtreekey_out'
 
76
LANGUAGE 'c' WITH (isstrict);
 
77
 
 
78
CREATE TYPE gbtreekey_var (
 
79
INTERNALLENGTH = VARIABLE,
 
80
INPUT  = gbtreekey_var_in,
 
81
OUTPUT = gbtreekey_var_out,
 
82
STORAGE = EXTENDED
 
83
);
 
84
 
 
85
 
 
86
 
 
87
--
 
88
--
 
89
--
 
90
-- oid ops
 
91
--
 
92
--
 
93
--
 
94
-- define the GiST support methods
 
95
CREATE FUNCTION gbt_oid_consistent(internal,oid,int2)
 
96
RETURNS bool
 
97
AS 'MODULE_PATHNAME'
 
98
LANGUAGE 'C';
 
99
 
 
100
CREATE FUNCTION gbt_oid_compress(internal)
 
101
RETURNS internal
 
102
AS 'MODULE_PATHNAME'
 
103
LANGUAGE 'C';
 
104
 
 
105
CREATE FUNCTION gbt_decompress(internal)
 
106
RETURNS internal
 
107
AS 'MODULE_PATHNAME'
 
108
LANGUAGE 'C';
 
109
 
 
110
CREATE FUNCTION gbt_oid_penalty(internal,internal,internal)
 
111
RETURNS internal
 
112
AS 'MODULE_PATHNAME'
 
113
LANGUAGE 'C' WITH (isstrict);
 
114
 
 
115
CREATE FUNCTION gbt_oid_picksplit(internal, internal)
 
116
RETURNS internal
 
117
AS 'MODULE_PATHNAME'
 
118
LANGUAGE 'C';
 
119
 
 
120
CREATE FUNCTION gbt_oid_union(bytea, internal)
 
121
RETURNS gbtreekey8
 
122
AS 'MODULE_PATHNAME'
 
123
LANGUAGE 'C';
 
124
 
 
125
CREATE FUNCTION gbt_oid_same(internal, internal, internal)
 
126
RETURNS internal
 
127
AS 'MODULE_PATHNAME'
 
128
LANGUAGE 'C';
 
129
 
 
130
-- Create the operator class
 
131
CREATE OPERATOR CLASS gist_oid_ops
 
132
DEFAULT FOR TYPE oid USING gist 
 
133
AS
 
134
        OPERATOR        1       <  ,
 
135
        OPERATOR        2       <= ,
 
136
        OPERATOR        3       =  ,
 
137
        OPERATOR        4       >= ,
 
138
        OPERATOR        5       >  ,
 
139
        FUNCTION        1       gbt_oid_consistent (internal, oid, int2),
 
140
        FUNCTION        2       gbt_oid_union (bytea, internal),
 
141
        FUNCTION        3       gbt_oid_compress (internal),
 
142
        FUNCTION        4       gbt_decompress (internal),
 
143
        FUNCTION        5       gbt_oid_penalty (internal, internal, internal),
 
144
        FUNCTION        6       gbt_oid_picksplit (internal, internal),
 
145
        FUNCTION        7       gbt_oid_same (internal, internal, internal),
 
146
        STORAGE         gbtreekey8;
 
147
 
 
148
 
 
149
--
 
150
--
 
151
--
 
152
-- int2 ops
 
153
--
 
154
--
 
155
--
 
156
-- define the GiST support methods
 
157
CREATE FUNCTION gbt_int2_consistent(internal,int2,int2)
 
158
RETURNS bool
 
159
AS 'MODULE_PATHNAME'
 
160
LANGUAGE 'C';
 
161
 
 
162
CREATE FUNCTION gbt_int2_compress(internal)
 
163
RETURNS internal
 
164
AS 'MODULE_PATHNAME'
 
165
LANGUAGE 'C';
 
166
 
 
167
CREATE FUNCTION gbt_int2_penalty(internal,internal,internal)
 
168
RETURNS internal
 
169
AS 'MODULE_PATHNAME'
 
170
LANGUAGE 'C' WITH (isstrict);
 
171
 
 
172
CREATE FUNCTION gbt_int2_picksplit(internal, internal)
 
173
RETURNS internal
 
174
AS 'MODULE_PATHNAME'
 
175
LANGUAGE 'C';
 
176
 
 
177
CREATE FUNCTION gbt_int2_union(bytea, internal)
 
178
RETURNS gbtreekey4
 
179
AS 'MODULE_PATHNAME'
 
180
LANGUAGE 'C';
 
181
 
 
182
CREATE FUNCTION gbt_int2_same(internal, internal, internal)
 
183
RETURNS internal
 
184
AS 'MODULE_PATHNAME'
 
185
LANGUAGE 'C';
 
186
 
 
187
-- Create the operator class
 
188
CREATE OPERATOR CLASS gist_int2_ops
 
189
DEFAULT FOR TYPE int2 USING gist 
 
190
AS
 
191
        OPERATOR        1       <  ,
 
192
        OPERATOR        2       <= ,
 
193
        OPERATOR        3       =  ,
 
194
        OPERATOR        4       >= ,
 
195
        OPERATOR        5       >  ,
 
196
        FUNCTION        1       gbt_int2_consistent (internal, int2, int2),
 
197
        FUNCTION        2       gbt_int2_union (bytea, internal),
 
198
        FUNCTION        3       gbt_int2_compress (internal),
 
199
        FUNCTION        4       gbt_decompress (internal),
 
200
        FUNCTION        5       gbt_int2_penalty (internal, internal, internal),
 
201
        FUNCTION        6       gbt_int2_picksplit (internal, internal),
 
202
        FUNCTION        7       gbt_int2_same (internal, internal, internal),
 
203
        STORAGE         gbtreekey4;
 
204
 
 
205
--
 
206
--
 
207
--
 
208
-- int4 ops
 
209
--
 
210
--
 
211
--
 
212
-- define the GiST support methods
 
213
CREATE FUNCTION gbt_int4_consistent(internal,int4,int2)
 
214
RETURNS bool
 
215
AS 'MODULE_PATHNAME'
 
216
LANGUAGE 'C';
 
217
 
 
218
CREATE FUNCTION gbt_int4_compress(internal)
 
219
RETURNS internal
 
220
AS 'MODULE_PATHNAME'
 
221
LANGUAGE 'C';
 
222
 
 
223
CREATE FUNCTION gbt_int4_penalty(internal,internal,internal)
 
224
RETURNS internal
 
225
AS 'MODULE_PATHNAME'
 
226
LANGUAGE 'C' WITH (isstrict);
 
227
 
 
228
CREATE FUNCTION gbt_int4_picksplit(internal, internal)
 
229
RETURNS internal
 
230
AS 'MODULE_PATHNAME'
 
231
LANGUAGE 'C';
 
232
 
 
233
CREATE FUNCTION gbt_int4_union(bytea, internal)
 
234
RETURNS gbtreekey8
 
235
AS 'MODULE_PATHNAME'
 
236
LANGUAGE 'C';
 
237
 
 
238
CREATE FUNCTION gbt_int4_same(internal, internal, internal)
 
239
RETURNS internal
 
240
AS 'MODULE_PATHNAME'
 
241
LANGUAGE 'C';
 
242
 
 
243
-- Create the operator class
 
244
CREATE OPERATOR CLASS gist_int4_ops
 
245
DEFAULT FOR TYPE int4 USING gist 
 
246
AS
 
247
        OPERATOR        1       <  ,
 
248
        OPERATOR        2       <= ,
 
249
        OPERATOR        3       =  ,
 
250
        OPERATOR        4       >= ,
 
251
        OPERATOR        5       >  ,
 
252
        FUNCTION        1       gbt_int4_consistent (internal, int4, int2),
 
253
        FUNCTION        2       gbt_int4_union (bytea, internal),
 
254
        FUNCTION        3       gbt_int4_compress (internal),
 
255
        FUNCTION        4       gbt_decompress (internal),
 
256
        FUNCTION        5       gbt_int4_penalty (internal, internal, internal),
 
257
        FUNCTION        6       gbt_int4_picksplit (internal, internal),
 
258
        FUNCTION        7       gbt_int4_same (internal, internal, internal),
 
259
        STORAGE         gbtreekey8;
 
260
 
 
261
--
 
262
--
 
263
--
 
264
-- int8 ops
 
265
--
 
266
--
 
267
--
 
268
-- define the GiST support methods
 
269
CREATE FUNCTION gbt_int8_consistent(internal,int8,int2)
 
270
RETURNS bool
 
271
AS 'MODULE_PATHNAME'
 
272
LANGUAGE 'C';
 
273
 
 
274
CREATE FUNCTION gbt_int8_compress(internal)
 
275
RETURNS internal
 
276
AS 'MODULE_PATHNAME'
 
277
LANGUAGE 'C';
 
278
 
 
279
CREATE FUNCTION gbt_int8_penalty(internal,internal,internal)
 
280
RETURNS internal
 
281
AS 'MODULE_PATHNAME'
 
282
LANGUAGE 'C' WITH (isstrict);
 
283
 
 
284
CREATE FUNCTION gbt_int8_picksplit(internal, internal)
 
285
RETURNS internal
 
286
AS 'MODULE_PATHNAME'
 
287
LANGUAGE 'C';
 
288
 
 
289
CREATE FUNCTION gbt_int8_union(bytea, internal)
 
290
RETURNS gbtreekey16
 
291
AS 'MODULE_PATHNAME'
 
292
LANGUAGE 'C';
 
293
 
 
294
CREATE FUNCTION gbt_int8_same(internal, internal, internal)
 
295
RETURNS internal
 
296
AS 'MODULE_PATHNAME'
 
297
LANGUAGE 'C';
 
298
 
 
299
-- Create the operator class
 
300
CREATE OPERATOR CLASS gist_int8_ops
 
301
DEFAULT FOR TYPE int8 USING gist 
 
302
AS
 
303
        OPERATOR        1       <  ,
 
304
        OPERATOR        2       <= ,
 
305
        OPERATOR        3       =  ,
 
306
        OPERATOR        4       >= ,
 
307
        OPERATOR        5       >  ,
 
308
        FUNCTION        1       gbt_int8_consistent (internal, int8, int2),
 
309
        FUNCTION        2       gbt_int8_union (bytea, internal),
 
310
        FUNCTION        3       gbt_int8_compress (internal),
 
311
        FUNCTION        4       gbt_decompress (internal),
 
312
        FUNCTION        5       gbt_int8_penalty (internal, internal, internal),
 
313
        FUNCTION        6       gbt_int8_picksplit (internal, internal),
 
314
        FUNCTION        7       gbt_int8_same (internal, internal, internal),
 
315
        STORAGE         gbtreekey16;
 
316
 
 
317
 
 
318
--
 
319
--
 
320
--
 
321
-- float4 ops
 
322
--
 
323
--
 
324
--
 
325
-- define the GiST support methods
 
326
CREATE FUNCTION gbt_float4_consistent(internal,float4,int2)
 
327
RETURNS bool
 
328
AS 'MODULE_PATHNAME'
 
329
LANGUAGE 'C';
 
330
 
 
331
CREATE FUNCTION gbt_float4_compress(internal)
 
332
RETURNS internal
 
333
AS 'MODULE_PATHNAME'
 
334
LANGUAGE 'C';
 
335
 
 
336
CREATE FUNCTION gbt_float4_penalty(internal,internal,internal)
 
337
RETURNS internal
 
338
AS 'MODULE_PATHNAME'
 
339
LANGUAGE 'C' WITH (isstrict);
 
340
 
 
341
CREATE FUNCTION gbt_float4_picksplit(internal, internal)
 
342
RETURNS internal
 
343
AS 'MODULE_PATHNAME'
 
344
LANGUAGE 'C';
 
345
 
 
346
CREATE FUNCTION gbt_float4_union(bytea, internal)
 
347
RETURNS gbtreekey8
 
348
AS 'MODULE_PATHNAME'
 
349
LANGUAGE 'C';
 
350
 
 
351
CREATE FUNCTION gbt_float4_same(internal, internal, internal)
 
352
RETURNS internal
 
353
AS 'MODULE_PATHNAME'
 
354
LANGUAGE 'C';
 
355
 
 
356
-- Create the operator class
 
357
CREATE OPERATOR CLASS gist_float4_ops
 
358
DEFAULT FOR TYPE float4 USING gist 
 
359
AS
 
360
        OPERATOR        1       <  ,
 
361
        OPERATOR        2       <= ,
 
362
        OPERATOR        3       =  ,
 
363
        OPERATOR        4       >= ,
 
364
        OPERATOR        5       >  ,
 
365
        FUNCTION        1       gbt_float4_consistent (internal, float4, int2),
 
366
        FUNCTION        2       gbt_float4_union (bytea, internal),
 
367
        FUNCTION        3       gbt_float4_compress (internal),
 
368
        FUNCTION        4       gbt_decompress (internal),
 
369
        FUNCTION        5       gbt_float4_penalty (internal, internal, internal),
 
370
        FUNCTION        6       gbt_float4_picksplit (internal, internal),
 
371
        FUNCTION        7       gbt_float4_same (internal, internal, internal),
 
372
        STORAGE         gbtreekey8;
 
373
 
 
374
 
 
375
 
 
376
 
 
377
--
 
378
--
 
379
--
 
380
-- float8 ops
 
381
--
 
382
--
 
383
--
 
384
-- define the GiST support methods
 
385
CREATE FUNCTION gbt_float8_consistent(internal,float8,int2)
 
386
RETURNS bool
 
387
AS 'MODULE_PATHNAME'
 
388
LANGUAGE 'C';
 
389
 
 
390
CREATE FUNCTION gbt_float8_compress(internal)
 
391
RETURNS internal
 
392
AS 'MODULE_PATHNAME'
 
393
LANGUAGE 'C';
 
394
 
 
395
CREATE FUNCTION gbt_float8_penalty(internal,internal,internal)
 
396
RETURNS internal
 
397
AS 'MODULE_PATHNAME'
 
398
LANGUAGE 'C' WITH (isstrict);
 
399
 
 
400
CREATE FUNCTION gbt_float8_picksplit(internal, internal)
 
401
RETURNS internal
 
402
AS 'MODULE_PATHNAME'
 
403
LANGUAGE 'C';
 
404
 
 
405
CREATE FUNCTION gbt_float8_union(bytea, internal)
 
406
RETURNS gbtreekey16
 
407
AS 'MODULE_PATHNAME'
 
408
LANGUAGE 'C';
 
409
 
 
410
CREATE FUNCTION gbt_float8_same(internal, internal, internal)
 
411
RETURNS internal
 
412
AS 'MODULE_PATHNAME'
 
413
LANGUAGE 'C';
 
414
 
 
415
-- Create the operator class
 
416
CREATE OPERATOR CLASS gist_float8_ops
 
417
DEFAULT FOR TYPE float8 USING gist 
 
418
AS
 
419
        OPERATOR        1       <  ,
 
420
        OPERATOR        2       <= ,
 
421
        OPERATOR        3       =  ,
 
422
        OPERATOR        4       >= ,
 
423
        OPERATOR        5       >  ,
 
424
        FUNCTION        1       gbt_float8_consistent (internal, float8, int2),
 
425
        FUNCTION        2       gbt_float8_union (bytea, internal),
 
426
        FUNCTION        3       gbt_float8_compress (internal),
 
427
        FUNCTION        4       gbt_decompress (internal),
 
428
        FUNCTION        5       gbt_float8_penalty (internal, internal, internal),
 
429
        FUNCTION        6       gbt_float8_picksplit (internal, internal),
 
430
        FUNCTION        7       gbt_float8_same (internal, internal, internal),
 
431
        STORAGE         gbtreekey16;
 
432
 
 
433
 
 
434
--
 
435
--
 
436
--
 
437
-- timestamp ops
 
438
-- 
 
439
--
 
440
--
 
441
 
 
442
CREATE FUNCTION gbt_ts_consistent(internal,timestamp,int2)
 
443
RETURNS bool
 
444
AS 'MODULE_PATHNAME'
 
445
LANGUAGE 'C';
 
446
 
 
447
CREATE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2)
 
448
RETURNS bool
 
449
AS 'MODULE_PATHNAME'
 
450
LANGUAGE 'C';
 
451
      
 
452
CREATE FUNCTION gbt_ts_compress(internal)
 
453
RETURNS internal
 
454
AS 'MODULE_PATHNAME'
 
455
LANGUAGE 'C';
 
456
 
 
457
CREATE FUNCTION gbt_tstz_compress(internal)
 
458
RETURNS internal
 
459
AS 'MODULE_PATHNAME'
 
460
LANGUAGE 'C';
 
461
 
 
462
CREATE FUNCTION gbt_ts_penalty(internal,internal,internal)
 
463
RETURNS internal
 
464
AS 'MODULE_PATHNAME'
 
465
LANGUAGE 'C' WITH (isstrict);
 
466
   
 
467
CREATE FUNCTION gbt_ts_picksplit(internal, internal)
 
468
RETURNS internal
 
469
AS 'MODULE_PATHNAME'
 
470
LANGUAGE 'C';
 
471
      
 
472
CREATE FUNCTION gbt_ts_union(bytea, internal)
 
473
RETURNS gbtreekey16
 
474
AS 'MODULE_PATHNAME'
 
475
LANGUAGE 'C';
 
476
 
 
477
CREATE FUNCTION gbt_ts_same(internal, internal, internal)
 
478
RETURNS internal
 
479
AS 'MODULE_PATHNAME'
 
480
LANGUAGE 'C';
 
481
 
 
482
-- Create the operator class
 
483
CREATE OPERATOR CLASS gist_timestamp_ops
 
484
DEFAULT FOR TYPE timestamp USING gist 
 
485
AS
 
486
        OPERATOR        1       <  ,
 
487
        OPERATOR        2       <= ,
 
488
        OPERATOR        3       =  ,
 
489
        OPERATOR        4       >= ,
 
490
        OPERATOR        5       >  ,
 
491
        FUNCTION        1       gbt_ts_consistent (internal, timestamp, int2),
 
492
        FUNCTION        2       gbt_ts_union (bytea, internal),
 
493
        FUNCTION        3       gbt_ts_compress (internal),
 
494
        FUNCTION        4       gbt_decompress (internal),
 
495
        FUNCTION        5       gbt_ts_penalty (internal, internal, internal),
 
496
        FUNCTION        6       gbt_ts_picksplit (internal, internal),
 
497
        FUNCTION        7       gbt_ts_same (internal, internal, internal),
 
498
        STORAGE         gbtreekey16;
 
499
 
 
500
 
 
501
-- Create the operator class
 
502
CREATE OPERATOR CLASS gist_timestamptz_ops
 
503
DEFAULT FOR TYPE timestamptz USING gist 
 
504
AS
 
505
        OPERATOR        1       <  ,
 
506
        OPERATOR        2       <= ,
 
507
        OPERATOR        3       =  ,
 
508
        OPERATOR        4       >= ,
 
509
        OPERATOR        5       >  ,
 
510
        FUNCTION        1       gbt_tstz_consistent (internal, timestamptz, int2),
 
511
        FUNCTION        2       gbt_ts_union (bytea, internal),
 
512
        FUNCTION        3       gbt_tstz_compress (internal),
 
513
        FUNCTION        4       gbt_decompress (internal),
 
514
        FUNCTION        5       gbt_ts_penalty (internal, internal, internal),
 
515
        FUNCTION        6       gbt_ts_picksplit (internal, internal),
 
516
        FUNCTION        7       gbt_ts_same (internal, internal, internal),
 
517
        STORAGE         gbtreekey16;
 
518
 
 
519
 
 
520
--
 
521
--
 
522
--
 
523
-- time ops
 
524
-- 
 
525
--
 
526
--
 
527
 
 
528
CREATE FUNCTION gbt_time_consistent(internal,time,int2)
 
529
RETURNS bool
 
530
AS 'MODULE_PATHNAME'
 
531
LANGUAGE 'C';
 
532
 
 
533
CREATE FUNCTION gbt_timetz_consistent(internal,timetz,int2)
 
534
RETURNS bool
 
535
AS 'MODULE_PATHNAME'
 
536
LANGUAGE 'C';
 
537
 
 
538
CREATE FUNCTION gbt_time_compress(internal)
 
539
RETURNS internal
 
540
AS 'MODULE_PATHNAME'
 
541
LANGUAGE 'C';
 
542
 
 
543
CREATE FUNCTION gbt_timetz_compress(internal)
 
544
RETURNS internal
 
545
AS 'MODULE_PATHNAME'
 
546
LANGUAGE 'C';
 
547
 
 
548
CREATE FUNCTION gbt_time_penalty(internal,internal,internal)
 
549
RETURNS internal
 
550
AS 'MODULE_PATHNAME'
 
551
LANGUAGE 'C' WITH (isstrict);
 
552
   
 
553
CREATE FUNCTION gbt_time_picksplit(internal, internal)
 
554
RETURNS internal
 
555
AS 'MODULE_PATHNAME'
 
556
LANGUAGE 'C';
 
557
      
 
558
CREATE FUNCTION gbt_time_union(bytea, internal)
 
559
RETURNS gbtreekey16
 
560
AS 'MODULE_PATHNAME'
 
561
LANGUAGE 'C';
 
562
 
 
563
CREATE FUNCTION gbt_time_same(internal, internal, internal)
 
564
RETURNS internal
 
565
AS 'MODULE_PATHNAME'
 
566
LANGUAGE 'C';
 
567
 
 
568
-- Create the operator class
 
569
CREATE OPERATOR CLASS gist_time_ops
 
570
DEFAULT FOR TYPE time USING gist 
 
571
AS
 
572
        OPERATOR        1       <  ,
 
573
        OPERATOR        2       <= ,
 
574
        OPERATOR        3       =  ,
 
575
        OPERATOR        4       >= ,
 
576
        OPERATOR        5       >  ,
 
577
        FUNCTION        1       gbt_time_consistent (internal, time, int2),
 
578
        FUNCTION        2       gbt_time_union (bytea, internal),
 
579
        FUNCTION        3       gbt_time_compress (internal),
 
580
        FUNCTION        4       gbt_decompress (internal),
 
581
        FUNCTION        5       gbt_time_penalty (internal, internal, internal),
 
582
        FUNCTION        6       gbt_time_picksplit (internal, internal),
 
583
        FUNCTION        7       gbt_time_same (internal, internal, internal),
 
584
        STORAGE         gbtreekey16;
 
585
 
 
586
CREATE OPERATOR CLASS gist_timetz_ops
 
587
DEFAULT FOR TYPE timetz USING gist 
 
588
AS
 
589
        OPERATOR        1       <   RECHECK ,
 
590
        OPERATOR        2       <=  RECHECK ,
 
591
        OPERATOR        3       =   RECHECK ,
 
592
        OPERATOR        4       >=  RECHECK ,
 
593
        OPERATOR        5       >   RECHECK ,
 
594
        FUNCTION        1       gbt_timetz_consistent (internal, timetz, int2),
 
595
        FUNCTION        2       gbt_time_union (bytea, internal),
 
596
        FUNCTION        3       gbt_timetz_compress (internal),
 
597
        FUNCTION        4       gbt_decompress (internal),
 
598
        FUNCTION        5       gbt_time_penalty (internal, internal, internal),
 
599
        FUNCTION        6       gbt_time_picksplit (internal, internal),
 
600
        FUNCTION        7       gbt_time_same (internal, internal, internal),
 
601
        STORAGE         gbtreekey16;
 
602
 
 
603
 
 
604
--
 
605
--
 
606
--
 
607
-- date ops
 
608
-- 
 
609
--
 
610
--
 
611
 
 
612
CREATE FUNCTION gbt_date_consistent(internal,date,int2)
 
613
RETURNS bool
 
614
AS 'MODULE_PATHNAME'
 
615
LANGUAGE 'C';
 
616
 
 
617
CREATE FUNCTION gbt_date_compress(internal)
 
618
RETURNS internal
 
619
AS 'MODULE_PATHNAME'
 
620
LANGUAGE 'C';
 
621
 
 
622
CREATE FUNCTION gbt_date_penalty(internal,internal,internal)
 
623
RETURNS internal
 
624
AS 'MODULE_PATHNAME'
 
625
LANGUAGE 'C' WITH (isstrict);
 
626
   
 
627
CREATE FUNCTION gbt_date_picksplit(internal, internal)
 
628
RETURNS internal
 
629
AS 'MODULE_PATHNAME'
 
630
LANGUAGE 'C';
 
631
      
 
632
CREATE FUNCTION gbt_date_union(bytea, internal)
 
633
RETURNS gbtreekey8
 
634
AS 'MODULE_PATHNAME'
 
635
LANGUAGE 'C';
 
636
 
 
637
CREATE FUNCTION gbt_date_same(internal, internal, internal)
 
638
RETURNS internal
 
639
AS 'MODULE_PATHNAME'
 
640
LANGUAGE 'C';
 
641
 
 
642
-- Create the operator class
 
643
CREATE OPERATOR CLASS gist_date_ops
 
644
DEFAULT FOR TYPE date USING gist 
 
645
AS
 
646
        OPERATOR        1       <  ,
 
647
        OPERATOR        2       <= ,
 
648
        OPERATOR        3       =  ,
 
649
        OPERATOR        4       >= ,
 
650
        OPERATOR        5       >  ,
 
651
        FUNCTION        1       gbt_date_consistent (internal, date, int2),
 
652
        FUNCTION        2       gbt_date_union (bytea, internal),
 
653
        FUNCTION        3       gbt_date_compress (internal),
 
654
        FUNCTION        4       gbt_decompress (internal),
 
655
        FUNCTION        5       gbt_date_penalty (internal, internal, internal),
 
656
        FUNCTION        6       gbt_date_picksplit (internal, internal),
 
657
        FUNCTION        7       gbt_date_same (internal, internal, internal),
 
658
        STORAGE         gbtreekey8;
 
659
 
 
660
 
 
661
--
 
662
--
 
663
--
 
664
-- interval ops
 
665
-- 
 
666
--
 
667
--
 
668
 
 
669
CREATE FUNCTION gbt_intv_consistent(internal,interval,int2)
 
670
RETURNS bool
 
671
AS 'MODULE_PATHNAME'
 
672
LANGUAGE 'C';
 
673
 
 
674
CREATE FUNCTION gbt_intv_compress(internal)
 
675
RETURNS internal
 
676
AS 'MODULE_PATHNAME'
 
677
LANGUAGE 'C';
 
678
 
 
679
CREATE FUNCTION gbt_intv_decompress(internal)
 
680
RETURNS internal
 
681
AS 'MODULE_PATHNAME'
 
682
LANGUAGE 'C';
 
683
 
 
684
CREATE FUNCTION gbt_intv_penalty(internal,internal,internal)
 
685
RETURNS internal
 
686
AS 'MODULE_PATHNAME'
 
687
LANGUAGE 'C' WITH (isstrict);
 
688
   
 
689
CREATE FUNCTION gbt_intv_picksplit(internal, internal)
 
690
RETURNS internal
 
691
AS 'MODULE_PATHNAME'
 
692
LANGUAGE 'C';
 
693
      
 
694
CREATE FUNCTION gbt_intv_union(bytea, internal)
 
695
RETURNS gbtreekey24
 
696
AS 'MODULE_PATHNAME'
 
697
LANGUAGE 'C';
 
698
 
 
699
CREATE FUNCTION gbt_intv_same(internal, internal, internal)
 
700
RETURNS internal
 
701
AS 'MODULE_PATHNAME'
 
702
LANGUAGE 'C';
 
703
 
 
704
-- Create the operator class
 
705
CREATE OPERATOR CLASS gist_interval_ops
 
706
DEFAULT FOR TYPE interval USING gist 
 
707
AS
 
708
        OPERATOR        1       < ,
 
709
        OPERATOR        2       <= ,
 
710
        OPERATOR        3       = ,
 
711
        OPERATOR        4       >= ,
 
712
        OPERATOR        5       > ,
 
713
        FUNCTION        1       gbt_intv_consistent (internal, interval, int2),
 
714
        FUNCTION        2       gbt_intv_union (bytea, internal),
 
715
        FUNCTION        3       gbt_intv_compress (internal),
 
716
        FUNCTION        4       gbt_intv_decompress (internal),
 
717
        FUNCTION        5       gbt_intv_penalty (internal, internal, internal),
 
718
        FUNCTION        6       gbt_intv_picksplit (internal, internal),
 
719
        FUNCTION        7       gbt_intv_same (internal, internal, internal),
 
720
        STORAGE         gbtreekey24;
 
721
 
 
722
--
 
723
--
 
724
--
 
725
-- cash ops
 
726
--
 
727
--
 
728
--
 
729
-- define the GiST support methods
 
730
CREATE FUNCTION gbt_cash_consistent(internal,money,int2)
 
731
RETURNS bool
 
732
AS 'MODULE_PATHNAME'
 
733
LANGUAGE 'C';
 
734
 
 
735
CREATE FUNCTION gbt_cash_compress(internal)
 
736
RETURNS internal
 
737
AS 'MODULE_PATHNAME'
 
738
LANGUAGE 'C';
 
739
 
 
740
CREATE FUNCTION gbt_cash_penalty(internal,internal,internal)
 
741
RETURNS internal
 
742
AS 'MODULE_PATHNAME'
 
743
LANGUAGE 'C' WITH (isstrict);
 
744
 
 
745
CREATE FUNCTION gbt_cash_picksplit(internal, internal)
 
746
RETURNS internal
 
747
AS 'MODULE_PATHNAME'
 
748
LANGUAGE 'C';
 
749
 
 
750
CREATE FUNCTION gbt_cash_union(bytea, internal)
 
751
RETURNS gbtreekey8
 
752
AS 'MODULE_PATHNAME'
 
753
LANGUAGE 'C';
 
754
 
 
755
CREATE FUNCTION gbt_cash_same(internal, internal, internal)
 
756
RETURNS internal
 
757
AS 'MODULE_PATHNAME'
 
758
LANGUAGE 'C';
 
759
 
 
760
-- Create the operator class
 
761
CREATE OPERATOR CLASS gist_cash_ops
 
762
DEFAULT FOR TYPE money USING gist 
 
763
AS
 
764
        OPERATOR        1       < ,
 
765
        OPERATOR        2       <= ,
 
766
        OPERATOR        3       = ,
 
767
        OPERATOR        4       >= ,
 
768
        OPERATOR        5       > ,
 
769
        FUNCTION        1       gbt_cash_consistent (internal, money, int2),
 
770
        FUNCTION        2       gbt_cash_union (bytea, internal),
 
771
        FUNCTION        3       gbt_cash_compress (internal),
 
772
        FUNCTION        4       gbt_decompress (internal),
 
773
        FUNCTION        5       gbt_cash_penalty (internal, internal, internal),
 
774
        FUNCTION        6       gbt_cash_picksplit (internal, internal),
 
775
        FUNCTION        7       gbt_cash_same (internal, internal, internal),
 
776
        STORAGE         gbtreekey8;
 
777
 
 
778
--
 
779
--
 
780
--
 
781
-- macaddr ops
 
782
--
 
783
--
 
784
--
 
785
-- define the GiST support methods
 
786
CREATE FUNCTION gbt_macad_consistent(internal,macaddr,int2)
 
787
RETURNS bool
 
788
AS 'MODULE_PATHNAME'
 
789
LANGUAGE 'C';
 
790
 
 
791
CREATE FUNCTION gbt_macad_compress(internal)
 
792
RETURNS internal
 
793
AS 'MODULE_PATHNAME'
 
794
LANGUAGE 'C';
 
795
 
 
796
CREATE FUNCTION gbt_macad_penalty(internal,internal,internal)
 
797
RETURNS internal
 
798
AS 'MODULE_PATHNAME'
 
799
LANGUAGE 'C' WITH (isstrict);
 
800
 
 
801
CREATE FUNCTION gbt_macad_picksplit(internal, internal)
 
802
RETURNS internal
 
803
AS 'MODULE_PATHNAME'
 
804
LANGUAGE 'C';
 
805
 
 
806
CREATE FUNCTION gbt_macad_union(bytea, internal)
 
807
RETURNS gbtreekey16
 
808
AS 'MODULE_PATHNAME'
 
809
LANGUAGE 'C';
 
810
 
 
811
CREATE FUNCTION gbt_macad_same(internal, internal, internal)
 
812
RETURNS internal
 
813
AS 'MODULE_PATHNAME'
 
814
LANGUAGE 'C';
 
815
 
 
816
-- Create the operator class
 
817
CREATE OPERATOR CLASS gist_macaddr_ops
 
818
DEFAULT FOR TYPE macaddr USING gist 
 
819
AS
 
820
        OPERATOR        1       < ,
 
821
        OPERATOR        2       <= ,
 
822
        OPERATOR        3       = ,
 
823
        OPERATOR        4       >= ,
 
824
        OPERATOR        5       > ,
 
825
        FUNCTION        1       gbt_macad_consistent (internal, macaddr, int2),
 
826
        FUNCTION        2       gbt_macad_union (bytea, internal),
 
827
        FUNCTION        3       gbt_macad_compress (internal),
 
828
        FUNCTION        4       gbt_decompress (internal),
 
829
        FUNCTION        5       gbt_macad_penalty (internal, internal, internal),
 
830
        FUNCTION        6       gbt_macad_picksplit (internal, internal),
 
831
        FUNCTION        7       gbt_macad_same (internal, internal, internal),
 
832
        STORAGE         gbtreekey16;
 
833
 
 
834
 
 
835
 
 
836
--
 
837
--
 
838
--
 
839
-- text/ bpchar ops
 
840
--
 
841
--
 
842
--
 
843
-- define the GiST support methods
 
844
CREATE FUNCTION gbt_text_consistent(internal,text,int2)
 
845
RETURNS bool
 
846
AS 'MODULE_PATHNAME'
 
847
LANGUAGE 'C';
 
848
 
 
849
CREATE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2)
 
850
RETURNS bool
 
851
AS 'MODULE_PATHNAME'
 
852
LANGUAGE 'C';
 
853
 
 
854
CREATE FUNCTION gbt_text_compress(internal)
 
855
RETURNS internal
 
856
AS 'MODULE_PATHNAME'
 
857
LANGUAGE 'C';
 
858
 
 
859
CREATE FUNCTION gbt_bpchar_compress(internal)
 
860
RETURNS internal
 
861
AS 'MODULE_PATHNAME'
 
862
LANGUAGE 'C';
 
863
 
 
864
CREATE FUNCTION gbt_text_penalty(internal,internal,internal)
 
865
RETURNS internal
 
866
AS 'MODULE_PATHNAME'
 
867
LANGUAGE 'C' WITH (isstrict);
 
868
 
 
869
CREATE FUNCTION gbt_text_picksplit(internal, internal)
 
870
RETURNS internal
 
871
AS 'MODULE_PATHNAME'
 
872
LANGUAGE 'C';
 
873
 
 
874
CREATE FUNCTION gbt_text_union(bytea, internal)
 
875
RETURNS gbtreekey_var
 
876
AS 'MODULE_PATHNAME'
 
877
LANGUAGE 'C';
 
878
 
 
879
CREATE FUNCTION gbt_text_same(internal, internal, internal)
 
880
RETURNS internal
 
881
AS 'MODULE_PATHNAME'
 
882
LANGUAGE 'C';
 
883
 
 
884
-- Create the operator class
 
885
CREATE OPERATOR CLASS gist_text_ops
 
886
DEFAULT FOR TYPE text USING gist 
 
887
AS
 
888
        OPERATOR        1       <  ,
 
889
        OPERATOR        2       <= ,
 
890
        OPERATOR        3       =  ,
 
891
        OPERATOR        4       >= ,
 
892
        OPERATOR        5       >  ,
 
893
        FUNCTION        1       gbt_text_consistent (internal, text, int2),
 
894
        FUNCTION        2       gbt_text_union (bytea, internal),
 
895
        FUNCTION        3       gbt_text_compress (internal),
 
896
        FUNCTION        4       gbt_decompress (internal),
 
897
        FUNCTION        5       gbt_text_penalty (internal, internal, internal),
 
898
        FUNCTION        6       gbt_text_picksplit (internal, internal),
 
899
        FUNCTION        7       gbt_text_same (internal, internal, internal),
 
900
        STORAGE                 gbtreekey_var;
 
901
 
 
902
 
 
903
---- Create the operator class
 
904
CREATE OPERATOR CLASS gist_bpchar_ops
 
905
DEFAULT FOR TYPE bpchar USING gist 
 
906
AS
 
907
        OPERATOR        1       <  ,
 
908
        OPERATOR        2       <= ,
 
909
        OPERATOR        3       =  ,
 
910
        OPERATOR        4       >= ,
 
911
        OPERATOR        5       >  ,
 
912
        FUNCTION        1       gbt_bpchar_consistent (internal, bpchar , int2),
 
913
        FUNCTION        2       gbt_text_union (bytea, internal),
 
914
        FUNCTION        3       gbt_bpchar_compress (internal),
 
915
        FUNCTION        4       gbt_decompress (internal),
 
916
        FUNCTION        5       gbt_text_penalty (internal, internal, internal),
 
917
        FUNCTION        6       gbt_text_picksplit (internal, internal),
 
918
        FUNCTION        7       gbt_text_same (internal, internal, internal),
 
919
        STORAGE                 gbtreekey_var;
 
920
 
 
921
 
 
922
 
 
923
--
 
924
--
 
925
-- bytea ops
 
926
--
 
927
--
 
928
--
 
929
-- define the GiST support methods
 
930
CREATE FUNCTION gbt_bytea_consistent(internal,bytea,int2)
 
931
RETURNS bool
 
932
AS 'MODULE_PATHNAME'
 
933
LANGUAGE 'C';
 
934
 
 
935
CREATE FUNCTION gbt_bytea_compress(internal)
 
936
RETURNS internal
 
937
AS 'MODULE_PATHNAME'
 
938
LANGUAGE 'C';
 
939
 
 
940
CREATE FUNCTION gbt_bytea_penalty(internal,internal,internal)
 
941
RETURNS internal
 
942
AS 'MODULE_PATHNAME'
 
943
LANGUAGE 'C' WITH (isstrict);
 
944
 
 
945
CREATE FUNCTION gbt_bytea_picksplit(internal, internal)
 
946
RETURNS internal
 
947
AS 'MODULE_PATHNAME'
 
948
LANGUAGE 'C';
 
949
 
 
950
CREATE FUNCTION gbt_bytea_union(bytea, internal)
 
951
RETURNS gbtreekey_var
 
952
AS 'MODULE_PATHNAME'
 
953
LANGUAGE 'C';
 
954
 
 
955
CREATE FUNCTION gbt_bytea_same(internal, internal, internal)
 
956
RETURNS internal
 
957
AS 'MODULE_PATHNAME'
 
958
LANGUAGE 'C';
 
959
 
 
960
-- Create the operator class
 
961
CREATE OPERATOR CLASS gist_bytea_ops
 
962
DEFAULT FOR TYPE bytea USING gist 
 
963
AS
 
964
        OPERATOR        1       <  ,
 
965
        OPERATOR        2       <= ,
 
966
        OPERATOR        3       =  ,
 
967
        OPERATOR        4       >= ,
 
968
        OPERATOR        5       >  ,
 
969
        FUNCTION        1       gbt_bytea_consistent (internal, bytea, int2),
 
970
        FUNCTION        2       gbt_bytea_union (bytea, internal),
 
971
        FUNCTION        3       gbt_bytea_compress (internal),
 
972
        FUNCTION        4       gbt_decompress (internal),
 
973
        FUNCTION        5       gbt_bytea_penalty (internal, internal, internal),
 
974
        FUNCTION        6       gbt_bytea_picksplit (internal, internal),
 
975
        FUNCTION        7       gbt_bytea_same (internal, internal, internal),
 
976
        STORAGE                 gbtreekey_var;
 
977
 
 
978
 
 
979
--
 
980
--
 
981
--
 
982
-- numeric ops
 
983
--
 
984
--
 
985
--
 
986
-- define the GiST support methods
 
987
CREATE FUNCTION gbt_numeric_consistent(internal,numeric,int2)
 
988
RETURNS bool
 
989
AS 'MODULE_PATHNAME'
 
990
LANGUAGE 'C';
 
991
 
 
992
CREATE FUNCTION gbt_numeric_compress(internal)
 
993
RETURNS internal
 
994
AS 'MODULE_PATHNAME'
 
995
LANGUAGE 'C';
 
996
 
 
997
CREATE FUNCTION gbt_numeric_penalty(internal,internal,internal)
 
998
RETURNS internal
 
999
AS 'MODULE_PATHNAME'
 
1000
LANGUAGE 'C' WITH (isstrict);
 
1001
 
 
1002
CREATE FUNCTION gbt_numeric_picksplit(internal, internal)
 
1003
RETURNS internal
 
1004
AS 'MODULE_PATHNAME'
 
1005
LANGUAGE 'C';
 
1006
 
 
1007
CREATE FUNCTION gbt_numeric_union(bytea, internal)
 
1008
RETURNS gbtreekey_var
 
1009
AS 'MODULE_PATHNAME'
 
1010
LANGUAGE 'C';
 
1011
 
 
1012
CREATE FUNCTION gbt_numeric_same(internal, internal, internal)
 
1013
RETURNS internal
 
1014
AS 'MODULE_PATHNAME'
 
1015
LANGUAGE 'C';
 
1016
 
 
1017
-- Create the operator class
 
1018
CREATE OPERATOR CLASS gist_numeric_ops
 
1019
DEFAULT FOR TYPE numeric USING gist 
 
1020
AS
 
1021
        OPERATOR        1       <  ,
 
1022
        OPERATOR        2       <= ,
 
1023
        OPERATOR        3       =  ,
 
1024
        OPERATOR        4       >= ,
 
1025
        OPERATOR        5       >  ,
 
1026
        FUNCTION        1       gbt_numeric_consistent (internal, numeric, int2),
 
1027
        FUNCTION        2       gbt_numeric_union (bytea, internal),
 
1028
        FUNCTION        3       gbt_numeric_compress (internal),
 
1029
        FUNCTION        4       gbt_decompress (internal),
 
1030
        FUNCTION        5       gbt_numeric_penalty (internal, internal, internal),
 
1031
        FUNCTION        6       gbt_numeric_picksplit (internal, internal),
 
1032
        FUNCTION        7       gbt_numeric_same (internal, internal, internal),
 
1033
        STORAGE                 gbtreekey_var;
 
1034
 
 
1035
--
 
1036
--
 
1037
-- bit ops
 
1038
--
 
1039
--
 
1040
--
 
1041
-- define the GiST support methods
 
1042
CREATE FUNCTION gbt_bit_consistent(internal,bit,int2)
 
1043
RETURNS bool
 
1044
AS 'MODULE_PATHNAME'
 
1045
LANGUAGE 'C';
 
1046
 
 
1047
CREATE FUNCTION gbt_bit_compress(internal)
 
1048
RETURNS internal
 
1049
AS 'MODULE_PATHNAME'
 
1050
LANGUAGE 'C';
 
1051
 
 
1052
CREATE FUNCTION gbt_bit_penalty(internal,internal,internal)
 
1053
RETURNS internal
 
1054
AS 'MODULE_PATHNAME'
 
1055
LANGUAGE 'C' WITH (isstrict);
 
1056
 
 
1057
CREATE FUNCTION gbt_bit_picksplit(internal, internal)
 
1058
RETURNS internal
 
1059
AS 'MODULE_PATHNAME'
 
1060
LANGUAGE 'C';
 
1061
 
 
1062
CREATE FUNCTION gbt_bit_union(bytea, internal)
 
1063
RETURNS gbtreekey_var
 
1064
AS 'MODULE_PATHNAME'
 
1065
LANGUAGE 'C';
 
1066
 
 
1067
CREATE FUNCTION gbt_bit_same(internal, internal, internal)
 
1068
RETURNS internal
 
1069
AS 'MODULE_PATHNAME'
 
1070
LANGUAGE 'C';
 
1071
 
 
1072
-- Create the operator class
 
1073
CREATE OPERATOR CLASS gist_bit_ops
 
1074
DEFAULT FOR TYPE bit USING gist 
 
1075
AS
 
1076
        OPERATOR        1       <  ,
 
1077
        OPERATOR        2       <= ,
 
1078
        OPERATOR        3       =  ,
 
1079
        OPERATOR        4       >= ,
 
1080
        OPERATOR        5       >  ,
 
1081
        FUNCTION        1       gbt_bit_consistent (internal, bit, int2),
 
1082
        FUNCTION        2       gbt_bit_union (bytea, internal),
 
1083
        FUNCTION        3       gbt_bit_compress (internal),
 
1084
        FUNCTION        4       gbt_decompress (internal),
 
1085
        FUNCTION        5       gbt_bit_penalty (internal, internal, internal),
 
1086
        FUNCTION        6       gbt_bit_picksplit (internal, internal),
 
1087
        FUNCTION        7       gbt_bit_same (internal, internal, internal),
 
1088
        STORAGE                 gbtreekey_var;
 
1089
 
 
1090
 
 
1091
-- Create the operator class
 
1092
CREATE OPERATOR CLASS gist_vbit_ops
 
1093
DEFAULT FOR TYPE varbit USING gist 
 
1094
AS
 
1095
        OPERATOR        1       <  ,
 
1096
        OPERATOR        2       <= ,
 
1097
        OPERATOR        3       =  ,
 
1098
        OPERATOR        4       >= ,
 
1099
        OPERATOR        5       >  ,
 
1100
        FUNCTION        1       gbt_bit_consistent (internal, bit, int2),
 
1101
        FUNCTION        2       gbt_bit_union (bytea, internal),
 
1102
        FUNCTION        3       gbt_bit_compress (internal),
 
1103
        FUNCTION        4       gbt_decompress (internal),
 
1104
        FUNCTION        5       gbt_bit_penalty (internal, internal, internal),
 
1105
        FUNCTION        6       gbt_bit_picksplit (internal, internal),
 
1106
        FUNCTION        7       gbt_bit_same (internal, internal, internal),
 
1107
        STORAGE                 gbtreekey_var;
 
1108
 
 
1109
 
 
1110
 
 
1111
--
 
1112
--
 
1113
--
 
1114
-- inet/cidr ops
 
1115
--
 
1116
--
 
1117
--
 
1118
-- define the GiST support methods
 
1119
CREATE FUNCTION gbt_inet_consistent(internal,inet,int2)
 
1120
RETURNS bool
 
1121
AS 'MODULE_PATHNAME'
 
1122
LANGUAGE 'C';
 
1123
 
 
1124
CREATE FUNCTION gbt_cidr_consistent(internal,cidr,int2)
 
1125
RETURNS bool
 
1126
AS 'MODULE_PATHNAME'
 
1127
LANGUAGE 'C';
 
1128
 
 
1129
CREATE FUNCTION gbt_inet_compress(internal)
 
1130
RETURNS internal
 
1131
AS 'MODULE_PATHNAME'
 
1132
LANGUAGE 'C';
 
1133
 
 
1134
CREATE FUNCTION gbt_cidr_compress(internal)
 
1135
RETURNS internal
 
1136
AS 'MODULE_PATHNAME'
 
1137
LANGUAGE 'C';
 
1138
 
 
1139
CREATE FUNCTION gbt_inet_penalty(internal,internal,internal)
 
1140
RETURNS internal
 
1141
AS 'MODULE_PATHNAME'
 
1142
LANGUAGE 'C' WITH (isstrict);
 
1143
 
 
1144
CREATE FUNCTION gbt_inet_picksplit(internal, internal)
 
1145
RETURNS internal
 
1146
AS 'MODULE_PATHNAME'
 
1147
LANGUAGE 'C';
 
1148
 
 
1149
CREATE FUNCTION gbt_inet_union(bytea, internal)
 
1150
RETURNS gbtreekey16
 
1151
AS 'MODULE_PATHNAME'
 
1152
LANGUAGE 'C';
 
1153
 
 
1154
CREATE FUNCTION gbt_inet_same(internal, internal, internal)
 
1155
RETURNS internal
 
1156
AS 'MODULE_PATHNAME'
 
1157
LANGUAGE 'C';
 
1158
 
 
1159
-- Create the operator class
 
1160
CREATE OPERATOR CLASS gist_inet_ops
 
1161
DEFAULT FOR TYPE inet USING gist 
 
1162
AS
 
1163
        OPERATOR        1       <   RECHECK ,
 
1164
        OPERATOR        2       <=  RECHECK ,
 
1165
        OPERATOR        3       =   RECHECK ,
 
1166
        OPERATOR        4       >=  RECHECK ,
 
1167
        OPERATOR        5       >   RECHECK ,
 
1168
        FUNCTION        1       gbt_inet_consistent (internal, inet, int2),
 
1169
        FUNCTION        2       gbt_inet_union (bytea, internal),
 
1170
        FUNCTION        3       gbt_inet_compress (internal),
 
1171
        FUNCTION        4       gbt_decompress (internal),
 
1172
        FUNCTION        5       gbt_inet_penalty (internal, internal, internal),
 
1173
        FUNCTION        6       gbt_inet_picksplit (internal, internal),
 
1174
        FUNCTION        7       gbt_inet_same (internal, internal, internal),
 
1175
        STORAGE         gbtreekey16;
 
1176
 
 
1177
-- Create the operator class
 
1178
CREATE OPERATOR CLASS gist_cidr_ops
 
1179
DEFAULT FOR TYPE cidr USING gist 
 
1180
AS
 
1181
        OPERATOR        1       <   RECHECK ,
 
1182
        OPERATOR        2       <=  RECHECK ,
 
1183
        OPERATOR        3       =   RECHECK ,
 
1184
        OPERATOR        4       >=  RECHECK ,
 
1185
        OPERATOR        5       >   RECHECK ,
 
1186
        FUNCTION        1       gbt_cidr_consistent (internal, cidr, int2),
 
1187
        FUNCTION        2       gbt_inet_union (bytea, internal),
 
1188
        FUNCTION        3       gbt_inet_compress (internal),
 
1189
        FUNCTION        4       gbt_decompress (internal),
 
1190
        FUNCTION        5       gbt_inet_penalty (internal, internal, internal),
 
1191
        FUNCTION        6       gbt_inet_picksplit (internal, internal),
 
1192
        FUNCTION        7       gbt_inet_same (internal, internal, internal),
 
1193
        STORAGE         gbtreekey16;