PolarDB-for-PostgreSQL

1
/* contrib/btree_gist/btree_gist--1.2.sql */
2

3
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
4
\echo Use "CREATE EXTENSION btree_gist" to load this file. \quit
5

6
CREATE FUNCTION gbtreekey4_in(cstring)
7
RETURNS gbtreekey4
8
AS 'MODULE_PATHNAME', 'gbtreekey_in'
9
LANGUAGE C IMMUTABLE STRICT;
10

11
CREATE FUNCTION gbtreekey4_out(gbtreekey4)
12
RETURNS cstring
13
AS 'MODULE_PATHNAME', 'gbtreekey_out'
14
LANGUAGE C IMMUTABLE STRICT;
15

16
CREATE TYPE gbtreekey4 (
17
	INTERNALLENGTH = 4,
18
	INPUT  = gbtreekey4_in,
19
	OUTPUT = gbtreekey4_out
20
);
21

22
CREATE FUNCTION gbtreekey8_in(cstring)
23
RETURNS gbtreekey8
24
AS 'MODULE_PATHNAME', 'gbtreekey_in'
25
LANGUAGE C IMMUTABLE STRICT;
26

27
CREATE FUNCTION gbtreekey8_out(gbtreekey8)
28
RETURNS cstring
29
AS 'MODULE_PATHNAME', 'gbtreekey_out'
30
LANGUAGE C IMMUTABLE STRICT;
31

32
CREATE TYPE gbtreekey8 (
33
	INTERNALLENGTH = 8,
34
	INPUT  = gbtreekey8_in,
35
	OUTPUT = gbtreekey8_out
36
);
37

38
CREATE FUNCTION gbtreekey16_in(cstring)
39
RETURNS gbtreekey16
40
AS 'MODULE_PATHNAME', 'gbtreekey_in'
41
LANGUAGE C IMMUTABLE STRICT;
42

43
CREATE FUNCTION gbtreekey16_out(gbtreekey16)
44
RETURNS cstring
45
AS 'MODULE_PATHNAME', 'gbtreekey_out'
46
LANGUAGE C IMMUTABLE STRICT;
47

48
CREATE TYPE gbtreekey16 (
49
	INTERNALLENGTH = 16,
50
	INPUT  = gbtreekey16_in,
51
	OUTPUT = gbtreekey16_out
52
);
53

54
CREATE FUNCTION gbtreekey32_in(cstring)
55
RETURNS gbtreekey32
56
AS 'MODULE_PATHNAME', 'gbtreekey_in'
57
LANGUAGE C IMMUTABLE STRICT;
58

59
CREATE FUNCTION gbtreekey32_out(gbtreekey32)
60
RETURNS cstring
61
AS 'MODULE_PATHNAME', 'gbtreekey_out'
62
LANGUAGE C IMMUTABLE STRICT;
63

64
CREATE TYPE gbtreekey32 (
65
	INTERNALLENGTH = 32,
66
	INPUT  = gbtreekey32_in,
67
	OUTPUT = gbtreekey32_out
68
);
69

70
CREATE FUNCTION gbtreekey_var_in(cstring)
71
RETURNS gbtreekey_var
72
AS 'MODULE_PATHNAME', 'gbtreekey_in'
73
LANGUAGE C IMMUTABLE STRICT;
74

75
CREATE FUNCTION gbtreekey_var_out(gbtreekey_var)
76
RETURNS cstring
77
AS 'MODULE_PATHNAME', 'gbtreekey_out'
78
LANGUAGE C IMMUTABLE STRICT;
79

80
CREATE TYPE gbtreekey_var (
81
	INTERNALLENGTH = VARIABLE,
82
	INPUT  = gbtreekey_var_in,
83
	OUTPUT = gbtreekey_var_out,
84
	STORAGE = EXTENDED
85
);
86

87
--distance operators
88

89
CREATE FUNCTION cash_dist(money, money)
90
RETURNS money
91
AS 'MODULE_PATHNAME'
92
LANGUAGE C IMMUTABLE STRICT;
93

94
CREATE OPERATOR <-> (
95
	LEFTARG = money,
96
	RIGHTARG = money,
97
	PROCEDURE = cash_dist,
98
	COMMUTATOR = '<->'
99
);
100

101
CREATE FUNCTION date_dist(date, date)
102
RETURNS int4
103
AS 'MODULE_PATHNAME'
104
LANGUAGE C IMMUTABLE STRICT;
105

106
CREATE OPERATOR <-> (
107
	LEFTARG = date,
108
	RIGHTARG = date,
109
	PROCEDURE = date_dist,
110
	COMMUTATOR = '<->'
111
);
112

113
CREATE FUNCTION float4_dist(float4, float4)
114
RETURNS float4
115
AS 'MODULE_PATHNAME'
116
LANGUAGE C IMMUTABLE STRICT;
117

118
CREATE OPERATOR <-> (
119
	LEFTARG = float4,
120
	RIGHTARG = float4,
121
	PROCEDURE = float4_dist,
122
	COMMUTATOR = '<->'
123
);
124

125
CREATE FUNCTION float8_dist(float8, float8)
126
RETURNS float8
127
AS 'MODULE_PATHNAME'
128
LANGUAGE C IMMUTABLE STRICT;
129

130
CREATE OPERATOR <-> (
131
	LEFTARG = float8,
132
	RIGHTARG = float8,
133
	PROCEDURE = float8_dist,
134
	COMMUTATOR = '<->'
135
);
136

137
CREATE FUNCTION int2_dist(int2, int2)
138
RETURNS int2
139
AS 'MODULE_PATHNAME'
140
LANGUAGE C IMMUTABLE STRICT;
141

142
CREATE OPERATOR <-> (
143
	LEFTARG = int2,
144
	RIGHTARG = int2,
145
	PROCEDURE = int2_dist,
146
	COMMUTATOR = '<->'
147
);
148

149
CREATE FUNCTION int4_dist(int4, int4)
150
RETURNS int4
151
AS 'MODULE_PATHNAME'
152
LANGUAGE C IMMUTABLE STRICT;
153

154
CREATE OPERATOR <-> (
155
	LEFTARG = int4,
156
	RIGHTARG = int4,
157
	PROCEDURE = int4_dist,
158
	COMMUTATOR = '<->'
159
);
160

161
CREATE FUNCTION int8_dist(int8, int8)
162
RETURNS int8
163
AS 'MODULE_PATHNAME'
164
LANGUAGE C IMMUTABLE STRICT;
165

166
CREATE OPERATOR <-> (
167
	LEFTARG = int8,
168
	RIGHTARG = int8,
169
	PROCEDURE = int8_dist,
170
	COMMUTATOR = '<->'
171
);
172

173
CREATE FUNCTION interval_dist(interval, interval)
174
RETURNS interval
175
AS 'MODULE_PATHNAME'
176
LANGUAGE C IMMUTABLE STRICT;
177

178
CREATE OPERATOR <-> (
179
	LEFTARG = interval,
180
	RIGHTARG = interval,
181
	PROCEDURE = interval_dist,
182
	COMMUTATOR = '<->'
183
);
184

185
CREATE FUNCTION oid_dist(oid, oid)
186
RETURNS oid
187
AS 'MODULE_PATHNAME'
188
LANGUAGE C IMMUTABLE STRICT;
189

190
CREATE OPERATOR <-> (
191
	LEFTARG = oid,
192
	RIGHTARG = oid,
193
	PROCEDURE = oid_dist,
194
	COMMUTATOR = '<->'
195
);
196

197
CREATE FUNCTION time_dist(time, time)
198
RETURNS interval
199
AS 'MODULE_PATHNAME'
200
LANGUAGE C IMMUTABLE STRICT;
201

202
CREATE OPERATOR <-> (
203
	LEFTARG = time,
204
	RIGHTARG = time,
205
	PROCEDURE = time_dist,
206
	COMMUTATOR = '<->'
207
);
208

209
CREATE FUNCTION ts_dist(timestamp, timestamp)
210
RETURNS interval
211
AS 'MODULE_PATHNAME'
212
LANGUAGE C IMMUTABLE STRICT;
213

214
CREATE OPERATOR <-> (
215
	LEFTARG = timestamp,
216
	RIGHTARG = timestamp,
217
	PROCEDURE = ts_dist,
218
	COMMUTATOR = '<->'
219
);
220

221
CREATE FUNCTION tstz_dist(timestamptz, timestamptz)
222
RETURNS interval
223
AS 'MODULE_PATHNAME'
224
LANGUAGE C IMMUTABLE STRICT;
225

226
CREATE OPERATOR <-> (
227
	LEFTARG = timestamptz,
228
	RIGHTARG = timestamptz,
229
	PROCEDURE = tstz_dist,
230
	COMMUTATOR = '<->'
231
);
232

233

234
--
235
--
236
--
237
-- oid ops
238
--
239
--
240
--
241
-- define the GiST support methods
242
CREATE FUNCTION gbt_oid_consistent(internal,oid,int2,oid,internal)
243
RETURNS bool
244
AS 'MODULE_PATHNAME'
245
LANGUAGE C IMMUTABLE STRICT;
246

247
CREATE FUNCTION gbt_oid_distance(internal,oid,int2,oid,internal)
248
RETURNS float8
249
AS 'MODULE_PATHNAME'
250
LANGUAGE C IMMUTABLE STRICT;
251

252
CREATE FUNCTION gbt_oid_fetch(internal)
253
RETURNS internal
254
AS 'MODULE_PATHNAME'
255
LANGUAGE C IMMUTABLE STRICT;
256

257
CREATE FUNCTION gbt_oid_compress(internal)
258
RETURNS internal
259
AS 'MODULE_PATHNAME'
260
LANGUAGE C IMMUTABLE STRICT;
261

262
CREATE FUNCTION gbt_decompress(internal)
263
RETURNS internal
264
AS 'MODULE_PATHNAME'
265
LANGUAGE C IMMUTABLE STRICT;
266

267
CREATE FUNCTION gbt_var_decompress(internal)
268
RETURNS internal
269
AS 'MODULE_PATHNAME'
270
LANGUAGE C IMMUTABLE STRICT;
271

272
CREATE FUNCTION gbt_var_fetch(internal)
273
RETURNS internal
274
AS 'MODULE_PATHNAME'
275
LANGUAGE C IMMUTABLE STRICT;
276

277
CREATE FUNCTION gbt_oid_penalty(internal,internal,internal)
278
RETURNS internal
279
AS 'MODULE_PATHNAME'
280
LANGUAGE C IMMUTABLE STRICT;
281

282
CREATE FUNCTION gbt_oid_picksplit(internal, internal)
283
RETURNS internal
284
AS 'MODULE_PATHNAME'
285
LANGUAGE C IMMUTABLE STRICT;
286

287
CREATE FUNCTION gbt_oid_union(internal, internal)
288
RETURNS gbtreekey8
289
AS 'MODULE_PATHNAME'
290
LANGUAGE C IMMUTABLE STRICT;
291

292
CREATE FUNCTION gbt_oid_same(gbtreekey8, gbtreekey8, internal)
293
RETURNS internal
294
AS 'MODULE_PATHNAME'
295
LANGUAGE C IMMUTABLE STRICT;
296

297
-- Create the operator class
298
CREATE OPERATOR CLASS gist_oid_ops
299
DEFAULT FOR TYPE oid USING gist
300
AS
301
	OPERATOR	1	<  ,
302
	OPERATOR	2	<= ,
303
	OPERATOR	3	=  ,
304
	OPERATOR	4	>= ,
305
	OPERATOR	5	>  ,
306
	FUNCTION	1	gbt_oid_consistent (internal, oid, int2, oid, internal),
307
	FUNCTION	2	gbt_oid_union (internal, internal),
308
	FUNCTION	3	gbt_oid_compress (internal),
309
	FUNCTION	4	gbt_decompress (internal),
310
	FUNCTION	5	gbt_oid_penalty (internal, internal, internal),
311
	FUNCTION	6	gbt_oid_picksplit (internal, internal),
312
	FUNCTION	7	gbt_oid_same (gbtreekey8, gbtreekey8, internal),
313
	STORAGE		gbtreekey8;
314

315
-- Add operators that are new in 9.1.  We do it like this, leaving them
316
-- "loose" in the operator family rather than bound into the opclass, because
317
-- that's the only state that can be reproduced during an upgrade from 9.0.
318
ALTER OPERATOR FAMILY gist_oid_ops USING gist ADD
319
	OPERATOR	6	<> (oid, oid) ,
320
	OPERATOR	15	<-> (oid, oid) FOR ORDER BY pg_catalog.oid_ops ,
321
	FUNCTION	8 (oid, oid) gbt_oid_distance (internal, oid, int2, oid, internal) ,
322
	-- Also add support function for index-only-scans, added in 9.5.
323
	FUNCTION	9 (oid, oid) gbt_oid_fetch (internal) ;
324

325

326
--
327
--
328
--
329
-- int2 ops
330
--
331
--
332
--
333
-- define the GiST support methods
334
CREATE FUNCTION gbt_int2_consistent(internal,int2,int2,oid,internal)
335
RETURNS bool
336
AS 'MODULE_PATHNAME'
337
LANGUAGE C IMMUTABLE STRICT;
338

339
CREATE FUNCTION gbt_int2_distance(internal,int2,int2,oid,internal)
340
RETURNS float8
341
AS 'MODULE_PATHNAME'
342
LANGUAGE C IMMUTABLE STRICT;
343

344
CREATE FUNCTION gbt_int2_compress(internal)
345
RETURNS internal
346
AS 'MODULE_PATHNAME'
347
LANGUAGE C IMMUTABLE STRICT;
348

349
CREATE FUNCTION gbt_int2_fetch(internal)
350
RETURNS internal
351
AS 'MODULE_PATHNAME'
352
LANGUAGE C IMMUTABLE STRICT;
353

354
CREATE FUNCTION gbt_int2_penalty(internal,internal,internal)
355
RETURNS internal
356
AS 'MODULE_PATHNAME'
357
LANGUAGE C IMMUTABLE STRICT;
358

359
CREATE FUNCTION gbt_int2_picksplit(internal, internal)
360
RETURNS internal
361
AS 'MODULE_PATHNAME'
362
LANGUAGE C IMMUTABLE STRICT;
363

364
CREATE FUNCTION gbt_int2_union(internal, internal)
365
RETURNS gbtreekey4
366
AS 'MODULE_PATHNAME'
367
LANGUAGE C IMMUTABLE STRICT;
368

369
CREATE FUNCTION gbt_int2_same(gbtreekey4, gbtreekey4, internal)
370
RETURNS internal
371
AS 'MODULE_PATHNAME'
372
LANGUAGE C IMMUTABLE STRICT;
373

374
-- Create the operator class
375
CREATE OPERATOR CLASS gist_int2_ops
376
DEFAULT FOR TYPE int2 USING gist
377
AS
378
	OPERATOR	1	<  ,
379
	OPERATOR	2	<= ,
380
	OPERATOR	3	=  ,
381
	OPERATOR	4	>= ,
382
	OPERATOR	5	>  ,
383
	FUNCTION	1	gbt_int2_consistent (internal, int2, int2, oid, internal),
384
	FUNCTION	2	gbt_int2_union (internal, internal),
385
	FUNCTION	3	gbt_int2_compress (internal),
386
	FUNCTION	4	gbt_decompress (internal),
387
	FUNCTION	5	gbt_int2_penalty (internal, internal, internal),
388
	FUNCTION	6	gbt_int2_picksplit (internal, internal),
389
	FUNCTION	7	gbt_int2_same (gbtreekey4, gbtreekey4, internal),
390
	STORAGE		gbtreekey4;
391

392
ALTER OPERATOR FAMILY gist_int2_ops USING gist ADD
393
	OPERATOR	6	<> (int2, int2) ,
394
	OPERATOR	15	<-> (int2, int2) FOR ORDER BY pg_catalog.integer_ops ,
395
	FUNCTION	8 (int2, int2) gbt_int2_distance (internal, int2, int2, oid, internal) ,
396
	FUNCTION	9 (int2, int2) gbt_int2_fetch (internal) ;
397

398
--
399
--
400
--
401
-- int4 ops
402
--
403
--
404
--
405
-- define the GiST support methods
406
CREATE FUNCTION gbt_int4_consistent(internal,int4,int2,oid,internal)
407
RETURNS bool
408
AS 'MODULE_PATHNAME'
409
LANGUAGE C IMMUTABLE STRICT;
410

411
CREATE FUNCTION gbt_int4_distance(internal,int4,int2,oid,internal)
412
RETURNS float8
413
AS 'MODULE_PATHNAME'
414
LANGUAGE C IMMUTABLE STRICT;
415

416
CREATE FUNCTION gbt_int4_compress(internal)
417
RETURNS internal
418
AS 'MODULE_PATHNAME'
419
LANGUAGE C IMMUTABLE STRICT;
420

421
CREATE FUNCTION gbt_int4_fetch(internal)
422
RETURNS internal
423
AS 'MODULE_PATHNAME'
424
LANGUAGE C IMMUTABLE STRICT;
425

426
CREATE FUNCTION gbt_int4_penalty(internal,internal,internal)
427
RETURNS internal
428
AS 'MODULE_PATHNAME'
429
LANGUAGE C IMMUTABLE STRICT;
430

431
CREATE FUNCTION gbt_int4_picksplit(internal, internal)
432
RETURNS internal
433
AS 'MODULE_PATHNAME'
434
LANGUAGE C IMMUTABLE STRICT;
435

436
CREATE FUNCTION gbt_int4_union(internal, internal)
437
RETURNS gbtreekey8
438
AS 'MODULE_PATHNAME'
439
LANGUAGE C IMMUTABLE STRICT;
440

441
CREATE FUNCTION gbt_int4_same(gbtreekey8, gbtreekey8, internal)
442
RETURNS internal
443
AS 'MODULE_PATHNAME'
444
LANGUAGE C IMMUTABLE STRICT;
445

446
-- Create the operator class
447
CREATE OPERATOR CLASS gist_int4_ops
448
DEFAULT FOR TYPE int4 USING gist
449
AS
450
	OPERATOR	1	<  ,
451
	OPERATOR	2	<= ,
452
	OPERATOR	3	=  ,
453
	OPERATOR	4	>= ,
454
	OPERATOR	5	>  ,
455
	FUNCTION	1	gbt_int4_consistent (internal, int4, int2, oid, internal),
456
	FUNCTION	2	gbt_int4_union (internal, internal),
457
	FUNCTION	3	gbt_int4_compress (internal),
458
	FUNCTION	4	gbt_decompress (internal),
459
	FUNCTION	5	gbt_int4_penalty (internal, internal, internal),
460
	FUNCTION	6	gbt_int4_picksplit (internal, internal),
461
	FUNCTION	7	gbt_int4_same (gbtreekey8, gbtreekey8, internal),
462
	STORAGE		gbtreekey8;
463

464
ALTER OPERATOR FAMILY gist_int4_ops USING gist ADD
465
	OPERATOR	6	<> (int4, int4) ,
466
	OPERATOR	15	<-> (int4, int4) FOR ORDER BY pg_catalog.integer_ops ,
467
	FUNCTION	8 (int4, int4) gbt_int4_distance (internal, int4, int2, oid, internal) ,
468
	FUNCTION	9 (int4, int4) gbt_int4_fetch (internal) ;
469

470

471
--
472
--
473
--
474
-- int8 ops
475
--
476
--
477
--
478
-- define the GiST support methods
479
CREATE FUNCTION gbt_int8_consistent(internal,int8,int2,oid,internal)
480
RETURNS bool
481
AS 'MODULE_PATHNAME'
482
LANGUAGE C IMMUTABLE STRICT;
483

484
CREATE FUNCTION gbt_int8_distance(internal,int8,int2,oid,internal)
485
RETURNS float8
486
AS 'MODULE_PATHNAME'
487
LANGUAGE C IMMUTABLE STRICT;
488

489
CREATE FUNCTION gbt_int8_compress(internal)
490
RETURNS internal
491
AS 'MODULE_PATHNAME'
492
LANGUAGE C IMMUTABLE STRICT;
493

494
CREATE FUNCTION gbt_int8_fetch(internal)
495
RETURNS internal
496
AS 'MODULE_PATHNAME'
497
LANGUAGE C IMMUTABLE STRICT;
498

499
CREATE FUNCTION gbt_int8_penalty(internal,internal,internal)
500
RETURNS internal
501
AS 'MODULE_PATHNAME'
502
LANGUAGE C IMMUTABLE STRICT;
503

504
CREATE FUNCTION gbt_int8_picksplit(internal, internal)
505
RETURNS internal
506
AS 'MODULE_PATHNAME'
507
LANGUAGE C IMMUTABLE STRICT;
508

509
CREATE FUNCTION gbt_int8_union(internal, internal)
510
RETURNS gbtreekey16
511
AS 'MODULE_PATHNAME'
512
LANGUAGE C IMMUTABLE STRICT;
513

514
CREATE FUNCTION gbt_int8_same(gbtreekey16, gbtreekey16, internal)
515
RETURNS internal
516
AS 'MODULE_PATHNAME'
517
LANGUAGE C IMMUTABLE STRICT;
518

519
-- Create the operator class
520
CREATE OPERATOR CLASS gist_int8_ops
521
DEFAULT FOR TYPE int8 USING gist
522
AS
523
	OPERATOR	1	<  ,
524
	OPERATOR	2	<= ,
525
	OPERATOR	3	=  ,
526
	OPERATOR	4	>= ,
527
	OPERATOR	5	>  ,
528
	FUNCTION	1	gbt_int8_consistent (internal, int8, int2, oid, internal),
529
	FUNCTION	2	gbt_int8_union (internal, internal),
530
	FUNCTION	3	gbt_int8_compress (internal),
531
	FUNCTION	4	gbt_decompress (internal),
532
	FUNCTION	5	gbt_int8_penalty (internal, internal, internal),
533
	FUNCTION	6	gbt_int8_picksplit (internal, internal),
534
	FUNCTION	7	gbt_int8_same (gbtreekey16, gbtreekey16, internal),
535
	STORAGE		gbtreekey16;
536

537
ALTER OPERATOR FAMILY gist_int8_ops USING gist ADD
538
	OPERATOR	6	<> (int8, int8) ,
539
	OPERATOR	15	<-> (int8, int8) FOR ORDER BY pg_catalog.integer_ops ,
540
	FUNCTION	8 (int8, int8) gbt_int8_distance (internal, int8, int2, oid, internal) ,
541
	FUNCTION	9 (int8, int8) gbt_int8_fetch (internal) ;
542

543
--
544
--
545
--
546
-- float4 ops
547
--
548
--
549
--
550
-- define the GiST support methods
551
CREATE FUNCTION gbt_float4_consistent(internal,float4,int2,oid,internal)
552
RETURNS bool
553
AS 'MODULE_PATHNAME'
554
LANGUAGE C IMMUTABLE STRICT;
555

556
CREATE FUNCTION gbt_float4_distance(internal,float4,int2,oid,internal)
557
RETURNS float8
558
AS 'MODULE_PATHNAME'
559
LANGUAGE C IMMUTABLE STRICT;
560

561
CREATE FUNCTION gbt_float4_compress(internal)
562
RETURNS internal
563
AS 'MODULE_PATHNAME'
564
LANGUAGE C IMMUTABLE STRICT;
565

566
CREATE FUNCTION gbt_float4_fetch(internal)
567
RETURNS internal
568
AS 'MODULE_PATHNAME'
569
LANGUAGE C IMMUTABLE STRICT;
570

571
CREATE FUNCTION gbt_float4_penalty(internal,internal,internal)
572
RETURNS internal
573
AS 'MODULE_PATHNAME'
574
LANGUAGE C IMMUTABLE STRICT;
575

576
CREATE FUNCTION gbt_float4_picksplit(internal, internal)
577
RETURNS internal
578
AS 'MODULE_PATHNAME'
579
LANGUAGE C IMMUTABLE STRICT;
580

581
CREATE FUNCTION gbt_float4_union(internal, internal)
582
RETURNS gbtreekey8
583
AS 'MODULE_PATHNAME'
584
LANGUAGE C IMMUTABLE STRICT;
585

586
CREATE FUNCTION gbt_float4_same(gbtreekey8, gbtreekey8, internal)
587
RETURNS internal
588
AS 'MODULE_PATHNAME'
589
LANGUAGE C IMMUTABLE STRICT;
590

591
-- Create the operator class
592
CREATE OPERATOR CLASS gist_float4_ops
593
DEFAULT FOR TYPE float4 USING gist
594
AS
595
	OPERATOR	1	<  ,
596
	OPERATOR	2	<= ,
597
	OPERATOR	3	=  ,
598
	OPERATOR	4	>= ,
599
	OPERATOR	5	>  ,
600
	FUNCTION	1	gbt_float4_consistent (internal, float4, int2, oid, internal),
601
	FUNCTION	2	gbt_float4_union (internal, internal),
602
	FUNCTION	3	gbt_float4_compress (internal),
603
	FUNCTION	4	gbt_decompress (internal),
604
	FUNCTION	5	gbt_float4_penalty (internal, internal, internal),
605
	FUNCTION	6	gbt_float4_picksplit (internal, internal),
606
	FUNCTION	7	gbt_float4_same (gbtreekey8, gbtreekey8, internal),
607
	STORAGE		gbtreekey8;
608

609
ALTER OPERATOR FAMILY gist_float4_ops USING gist ADD
610
	OPERATOR	6	<> (float4, float4) ,
611
	OPERATOR	15	<-> (float4, float4) FOR ORDER BY pg_catalog.float_ops ,
612
	FUNCTION	8 (float4, float4) gbt_float4_distance (internal, float4, int2, oid, internal) ,
613
	FUNCTION	9 (float4, float4) gbt_float4_fetch (internal) ;
614

615
--
616
--
617
--
618
-- float8 ops
619
--
620
--
621
--
622
-- define the GiST support methods
623
CREATE FUNCTION gbt_float8_consistent(internal,float8,int2,oid,internal)
624
RETURNS bool
625
AS 'MODULE_PATHNAME'
626
LANGUAGE C IMMUTABLE STRICT;
627

628
CREATE FUNCTION gbt_float8_distance(internal,float8,int2,oid,internal)
629
RETURNS float8
630
AS 'MODULE_PATHNAME'
631
LANGUAGE C IMMUTABLE STRICT;
632

633
CREATE FUNCTION gbt_float8_compress(internal)
634
RETURNS internal
635
AS 'MODULE_PATHNAME'
636
LANGUAGE C IMMUTABLE STRICT;
637

638
CREATE FUNCTION gbt_float8_fetch(internal)
639
RETURNS internal
640
AS 'MODULE_PATHNAME'
641
LANGUAGE C IMMUTABLE STRICT;
642

643
CREATE FUNCTION gbt_float8_penalty(internal,internal,internal)
644
RETURNS internal
645
AS 'MODULE_PATHNAME'
646
LANGUAGE C IMMUTABLE STRICT;
647

648
CREATE FUNCTION gbt_float8_picksplit(internal, internal)
649
RETURNS internal
650
AS 'MODULE_PATHNAME'
651
LANGUAGE C IMMUTABLE STRICT;
652

653
CREATE FUNCTION gbt_float8_union(internal, internal)
654
RETURNS gbtreekey16
655
AS 'MODULE_PATHNAME'
656
LANGUAGE C IMMUTABLE STRICT;
657

658
CREATE FUNCTION gbt_float8_same(gbtreekey16, gbtreekey16, internal)
659
RETURNS internal
660
AS 'MODULE_PATHNAME'
661
LANGUAGE C IMMUTABLE STRICT;
662

663
-- Create the operator class
664
CREATE OPERATOR CLASS gist_float8_ops
665
DEFAULT FOR TYPE float8 USING gist
666
AS
667
	OPERATOR	1	<  ,
668
	OPERATOR	2	<= ,
669
	OPERATOR	3	=  ,
670
	OPERATOR	4	>= ,
671
	OPERATOR	5	>  ,
672
	FUNCTION	1	gbt_float8_consistent (internal, float8, int2, oid, internal),
673
	FUNCTION	2	gbt_float8_union (internal, internal),
674
	FUNCTION	3	gbt_float8_compress (internal),
675
	FUNCTION	4	gbt_decompress (internal),
676
	FUNCTION	5	gbt_float8_penalty (internal, internal, internal),
677
	FUNCTION	6	gbt_float8_picksplit (internal, internal),
678
	FUNCTION	7	gbt_float8_same (gbtreekey16, gbtreekey16, internal),
679
	STORAGE		gbtreekey16;
680

681
ALTER OPERATOR FAMILY gist_float8_ops USING gist ADD
682
	OPERATOR	6	<> (float8, float8) ,
683
	OPERATOR	15	<-> (float8, float8) FOR ORDER BY pg_catalog.float_ops ,
684
	FUNCTION	8 (float8, float8) gbt_float8_distance (internal, float8, int2, oid, internal) ,
685
	FUNCTION	9 (float8, float8) gbt_float8_fetch (internal) ;
686

687
--
688
--
689
--
690
-- timestamp ops
691
--
692
--
693
--
694

695
CREATE FUNCTION gbt_ts_consistent(internal,timestamp,int2,oid,internal)
696
RETURNS bool
697
AS 'MODULE_PATHNAME'
698
LANGUAGE C IMMUTABLE STRICT;
699

700
CREATE FUNCTION gbt_ts_distance(internal,timestamp,int2,oid,internal)
701
RETURNS float8
702
AS 'MODULE_PATHNAME'
703
LANGUAGE C IMMUTABLE STRICT;
704

705
CREATE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2,oid,internal)
706
RETURNS bool
707
AS 'MODULE_PATHNAME'
708
LANGUAGE C IMMUTABLE STRICT;
709

710
CREATE FUNCTION gbt_tstz_distance(internal,timestamptz,int2,oid,internal)
711
RETURNS float8
712
AS 'MODULE_PATHNAME'
713
LANGUAGE C IMMUTABLE STRICT;
714

715
CREATE FUNCTION gbt_ts_compress(internal)
716
RETURNS internal
717
AS 'MODULE_PATHNAME'
718
LANGUAGE C IMMUTABLE STRICT;
719

720
CREATE FUNCTION gbt_tstz_compress(internal)
721
RETURNS internal
722
AS 'MODULE_PATHNAME'
723
LANGUAGE C IMMUTABLE STRICT;
724

725
CREATE FUNCTION gbt_ts_fetch(internal)
726
RETURNS internal
727
AS 'MODULE_PATHNAME'
728
LANGUAGE C IMMUTABLE STRICT;
729

730
CREATE FUNCTION gbt_ts_penalty(internal,internal,internal)
731
RETURNS internal
732
AS 'MODULE_PATHNAME'
733
LANGUAGE C IMMUTABLE STRICT;
734

735
CREATE FUNCTION gbt_ts_picksplit(internal, internal)
736
RETURNS internal
737
AS 'MODULE_PATHNAME'
738
LANGUAGE C IMMUTABLE STRICT;
739

740
CREATE FUNCTION gbt_ts_union(internal, internal)
741
RETURNS gbtreekey16
742
AS 'MODULE_PATHNAME'
743
LANGUAGE C IMMUTABLE STRICT;
744

745
CREATE FUNCTION gbt_ts_same(gbtreekey16, gbtreekey16, internal)
746
RETURNS internal
747
AS 'MODULE_PATHNAME'
748
LANGUAGE C IMMUTABLE STRICT;
749

750
-- Create the operator class
751
CREATE OPERATOR CLASS gist_timestamp_ops
752
DEFAULT FOR TYPE timestamp USING gist
753
AS
754
	OPERATOR	1	<  ,
755
	OPERATOR	2	<= ,
756
	OPERATOR	3	=  ,
757
	OPERATOR	4	>= ,
758
	OPERATOR	5	>  ,
759
	FUNCTION	1	gbt_ts_consistent (internal, timestamp, int2, oid, internal),
760
	FUNCTION	2	gbt_ts_union (internal, internal),
761
	FUNCTION	3	gbt_ts_compress (internal),
762
	FUNCTION	4	gbt_decompress (internal),
763
	FUNCTION	5	gbt_ts_penalty (internal, internal, internal),
764
	FUNCTION	6	gbt_ts_picksplit (internal, internal),
765
	FUNCTION	7	gbt_ts_same (gbtreekey16, gbtreekey16, internal),
766
	STORAGE		gbtreekey16;
767

768
ALTER OPERATOR FAMILY gist_timestamp_ops USING gist ADD
769
	OPERATOR	6	<> (timestamp, timestamp) ,
770
	OPERATOR	15	<-> (timestamp, timestamp) FOR ORDER BY pg_catalog.interval_ops ,
771
	FUNCTION	8 (timestamp, timestamp) gbt_ts_distance (internal, timestamp, int2, oid, internal) ,
772
	FUNCTION	9 (timestamp, timestamp) gbt_ts_fetch (internal) ;
773

774
-- Create the operator class
775
CREATE OPERATOR CLASS gist_timestamptz_ops
776
DEFAULT FOR TYPE timestamptz USING gist
777
AS
778
	OPERATOR	1	<  ,
779
	OPERATOR	2	<= ,
780
	OPERATOR	3	=  ,
781
	OPERATOR	4	>= ,
782
	OPERATOR	5	>  ,
783
	FUNCTION	1	gbt_tstz_consistent (internal, timestamptz, int2, oid, internal),
784
	FUNCTION	2	gbt_ts_union (internal, internal),
785
	FUNCTION	3	gbt_tstz_compress (internal),
786
	FUNCTION	4	gbt_decompress (internal),
787
	FUNCTION	5	gbt_ts_penalty (internal, internal, internal),
788
	FUNCTION	6	gbt_ts_picksplit (internal, internal),
789
	FUNCTION	7	gbt_ts_same (gbtreekey16, gbtreekey16, internal),
790
	STORAGE		gbtreekey16;
791

792
ALTER OPERATOR FAMILY gist_timestamptz_ops USING gist ADD
793
	OPERATOR	6	<> (timestamptz, timestamptz) ,
794
	OPERATOR	15	<-> (timestamptz, timestamptz) FOR ORDER BY pg_catalog.interval_ops ,
795
	FUNCTION	8 (timestamptz, timestamptz) gbt_tstz_distance (internal, timestamptz, int2, oid, internal) ,
796
	FUNCTION	9 (timestamptz, timestamptz) gbt_ts_fetch (internal) ;
797

798
--
799
--
800
--
801
-- time ops
802
--
803
--
804
--
805

806
CREATE FUNCTION gbt_time_consistent(internal,time,int2,oid,internal)
807
RETURNS bool
808
AS 'MODULE_PATHNAME'
809
LANGUAGE C IMMUTABLE STRICT;
810

811
CREATE FUNCTION gbt_time_distance(internal,time,int2,oid,internal)
812
RETURNS float8
813
AS 'MODULE_PATHNAME'
814
LANGUAGE C IMMUTABLE STRICT;
815

816
CREATE FUNCTION gbt_timetz_consistent(internal,timetz,int2,oid,internal)
817
RETURNS bool
818
AS 'MODULE_PATHNAME'
819
LANGUAGE C IMMUTABLE STRICT;
820

821
CREATE FUNCTION gbt_time_compress(internal)
822
RETURNS internal
823
AS 'MODULE_PATHNAME'
824
LANGUAGE C IMMUTABLE STRICT;
825

826
CREATE FUNCTION gbt_timetz_compress(internal)
827
RETURNS internal
828
AS 'MODULE_PATHNAME'
829
LANGUAGE C IMMUTABLE STRICT;
830

831
CREATE FUNCTION gbt_time_fetch(internal)
832
RETURNS internal
833
AS 'MODULE_PATHNAME'
834
LANGUAGE C IMMUTABLE STRICT;
835

836
CREATE FUNCTION gbt_time_penalty(internal,internal,internal)
837
RETURNS internal
838
AS 'MODULE_PATHNAME'
839
LANGUAGE C IMMUTABLE STRICT;
840

841
CREATE FUNCTION gbt_time_picksplit(internal, internal)
842
RETURNS internal
843
AS 'MODULE_PATHNAME'
844
LANGUAGE C IMMUTABLE STRICT;
845

846
CREATE FUNCTION gbt_time_union(internal, internal)
847
RETURNS gbtreekey16
848
AS 'MODULE_PATHNAME'
849
LANGUAGE C IMMUTABLE STRICT;
850

851
CREATE FUNCTION gbt_time_same(gbtreekey16, gbtreekey16, internal)
852
RETURNS internal
853
AS 'MODULE_PATHNAME'
854
LANGUAGE C IMMUTABLE STRICT;
855

856
-- Create the operator class
857
CREATE OPERATOR CLASS gist_time_ops
858
DEFAULT FOR TYPE time USING gist
859
AS
860
	OPERATOR	1	<  ,
861
	OPERATOR	2	<= ,
862
	OPERATOR	3	=  ,
863
	OPERATOR	4	>= ,
864
	OPERATOR	5	>  ,
865
	FUNCTION	1	gbt_time_consistent (internal, time, int2, oid, internal),
866
	FUNCTION	2	gbt_time_union (internal, internal),
867
	FUNCTION	3	gbt_time_compress (internal),
868
	FUNCTION	4	gbt_decompress (internal),
869
	FUNCTION	5	gbt_time_penalty (internal, internal, internal),
870
	FUNCTION	6	gbt_time_picksplit (internal, internal),
871
	FUNCTION	7	gbt_time_same (gbtreekey16, gbtreekey16, internal),
872
	STORAGE		gbtreekey16;
873

874
ALTER OPERATOR FAMILY gist_time_ops USING gist ADD
875
	OPERATOR	6	<> (time, time) ,
876
	OPERATOR	15	<-> (time, time) FOR ORDER BY pg_catalog.interval_ops ,
877
	FUNCTION	8 (time, time) gbt_time_distance (internal, time, int2, oid, internal) ,
878
	FUNCTION	9 (time, time) gbt_time_fetch (internal) ;
879

880

881
CREATE OPERATOR CLASS gist_timetz_ops
882
DEFAULT FOR TYPE timetz USING gist
883
AS
884
	OPERATOR	1	<   ,
885
	OPERATOR	2	<=  ,
886
	OPERATOR	3	=   ,
887
	OPERATOR	4	>=  ,
888
	OPERATOR	5	>   ,
889
	FUNCTION	1	gbt_timetz_consistent (internal, timetz, int2, oid, internal),
890
	FUNCTION	2	gbt_time_union (internal, internal),
891
	FUNCTION	3	gbt_timetz_compress (internal),
892
	FUNCTION	4	gbt_decompress (internal),
893
	FUNCTION	5	gbt_time_penalty (internal, internal, internal),
894
	FUNCTION	6	gbt_time_picksplit (internal, internal),
895
	FUNCTION	7	gbt_time_same (gbtreekey16, gbtreekey16, internal),
896
	STORAGE		gbtreekey16;
897

898
ALTER OPERATOR FAMILY gist_timetz_ops USING gist ADD
899
	OPERATOR	6	<> (timetz, timetz) ;
900
	-- no 'fetch' function, as the compress function is lossy.
901

902

903
--
904
--
905
--
906
-- date ops
907
--
908
--
909
--
910

911
CREATE FUNCTION gbt_date_consistent(internal,date,int2,oid,internal)
912
RETURNS bool
913
AS 'MODULE_PATHNAME'
914
LANGUAGE C IMMUTABLE STRICT;
915

916
CREATE FUNCTION gbt_date_distance(internal,date,int2,oid,internal)
917
RETURNS float8
918
AS 'MODULE_PATHNAME'
919
LANGUAGE C IMMUTABLE STRICT;
920

921
CREATE FUNCTION gbt_date_compress(internal)
922
RETURNS internal
923
AS 'MODULE_PATHNAME'
924
LANGUAGE C IMMUTABLE STRICT;
925

926
CREATE FUNCTION gbt_date_fetch(internal)
927
RETURNS internal
928
AS 'MODULE_PATHNAME'
929
LANGUAGE C IMMUTABLE STRICT;
930

931
CREATE FUNCTION gbt_date_penalty(internal,internal,internal)
932
RETURNS internal
933
AS 'MODULE_PATHNAME'
934
LANGUAGE C IMMUTABLE STRICT;
935

936
CREATE FUNCTION gbt_date_picksplit(internal, internal)
937
RETURNS internal
938
AS 'MODULE_PATHNAME'
939
LANGUAGE C IMMUTABLE STRICT;
940

941
CREATE FUNCTION gbt_date_union(internal, internal)
942
RETURNS gbtreekey8
943
AS 'MODULE_PATHNAME'
944
LANGUAGE C IMMUTABLE STRICT;
945

946
CREATE FUNCTION gbt_date_same(gbtreekey8, gbtreekey8, internal)
947
RETURNS internal
948
AS 'MODULE_PATHNAME'
949
LANGUAGE C IMMUTABLE STRICT;
950

951
-- Create the operator class
952
CREATE OPERATOR CLASS gist_date_ops
953
DEFAULT FOR TYPE date USING gist
954
AS
955
	OPERATOR	1	<  ,
956
	OPERATOR	2	<= ,
957
	OPERATOR	3	=  ,
958
	OPERATOR	4	>= ,
959
	OPERATOR	5	>  ,
960
	FUNCTION	1	gbt_date_consistent (internal, date, int2, oid, internal),
961
	FUNCTION	2	gbt_date_union (internal, internal),
962
	FUNCTION	3	gbt_date_compress (internal),
963
	FUNCTION	4	gbt_decompress (internal),
964
	FUNCTION	5	gbt_date_penalty (internal, internal, internal),
965
	FUNCTION	6	gbt_date_picksplit (internal, internal),
966
	FUNCTION	7	gbt_date_same (gbtreekey8, gbtreekey8, internal),
967
	STORAGE		gbtreekey8;
968

969
ALTER OPERATOR FAMILY gist_date_ops USING gist ADD
970
	OPERATOR	6	<> (date, date) ,
971
	OPERATOR	15	<-> (date, date) FOR ORDER BY pg_catalog.integer_ops ,
972
	FUNCTION	8 (date, date) gbt_date_distance (internal, date, int2, oid, internal) ,
973
	FUNCTION	9 (date, date) gbt_date_fetch (internal) ;
974

975

976
--
977
--
978
--
979
-- interval ops
980
--
981
--
982
--
983

984
CREATE FUNCTION gbt_intv_consistent(internal,interval,int2,oid,internal)
985
RETURNS bool
986
AS 'MODULE_PATHNAME'
987
LANGUAGE C IMMUTABLE STRICT;
988

989
CREATE FUNCTION gbt_intv_distance(internal,interval,int2,oid,internal)
990
RETURNS float8
991
AS 'MODULE_PATHNAME'
992
LANGUAGE C IMMUTABLE STRICT;
993

994
CREATE FUNCTION gbt_intv_compress(internal)
995
RETURNS internal
996
AS 'MODULE_PATHNAME'
997
LANGUAGE C IMMUTABLE STRICT;
998

999
CREATE FUNCTION gbt_intv_decompress(internal)
1000
RETURNS internal
1001
AS 'MODULE_PATHNAME'
1002
LANGUAGE C IMMUTABLE STRICT;
1003

1004
CREATE FUNCTION gbt_intv_fetch(internal)
1005
RETURNS internal
1006
AS 'MODULE_PATHNAME'
1007
LANGUAGE C IMMUTABLE STRICT;
1008

1009
CREATE FUNCTION gbt_intv_penalty(internal,internal,internal)
1010
RETURNS internal
1011
AS 'MODULE_PATHNAME'
1012
LANGUAGE C IMMUTABLE STRICT;
1013

1014
CREATE FUNCTION gbt_intv_picksplit(internal, internal)
1015
RETURNS internal
1016
AS 'MODULE_PATHNAME'
1017
LANGUAGE C IMMUTABLE STRICT;
1018

1019
CREATE FUNCTION gbt_intv_union(internal, internal)
1020
RETURNS gbtreekey32
1021
AS 'MODULE_PATHNAME'
1022
LANGUAGE C IMMUTABLE STRICT;
1023

1024
CREATE FUNCTION gbt_intv_same(gbtreekey32, gbtreekey32, internal)
1025
RETURNS internal
1026
AS 'MODULE_PATHNAME'
1027
LANGUAGE C IMMUTABLE STRICT;
1028

1029
-- Create the operator class
1030
CREATE OPERATOR CLASS gist_interval_ops
1031
DEFAULT FOR TYPE interval USING gist
1032
AS
1033
	OPERATOR	1	< ,
1034
	OPERATOR	2	<= ,
1035
	OPERATOR	3	= ,
1036
	OPERATOR	4	>= ,
1037
	OPERATOR	5	> ,
1038
	FUNCTION	1	gbt_intv_consistent (internal, interval, int2, oid, internal),
1039
	FUNCTION	2	gbt_intv_union (internal, internal),
1040
	FUNCTION	3	gbt_intv_compress (internal),
1041
	FUNCTION	4	gbt_intv_decompress (internal),
1042
	FUNCTION	5	gbt_intv_penalty (internal, internal, internal),
1043
	FUNCTION	6	gbt_intv_picksplit (internal, internal),
1044
	FUNCTION	7	gbt_intv_same (gbtreekey32, gbtreekey32, internal),
1045
	STORAGE		gbtreekey32;
1046

1047
ALTER OPERATOR FAMILY gist_interval_ops USING gist ADD
1048
	OPERATOR	6	<> (interval, interval) ,
1049
	OPERATOR	15	<-> (interval, interval) FOR ORDER BY pg_catalog.interval_ops ,
1050
	FUNCTION	8 (interval, interval) gbt_intv_distance (internal, interval, int2, oid, internal) ,
1051
	FUNCTION	9 (interval, interval) gbt_intv_fetch (internal) ;
1052

1053

1054
--
1055
--
1056
--
1057
-- cash ops
1058
--
1059
--
1060
--
1061
-- define the GiST support methods
1062
CREATE FUNCTION gbt_cash_consistent(internal,money,int2,oid,internal)
1063
RETURNS bool
1064
AS 'MODULE_PATHNAME'
1065
LANGUAGE C IMMUTABLE STRICT;
1066

1067
CREATE FUNCTION gbt_cash_distance(internal,money,int2,oid,internal)
1068
RETURNS float8
1069
AS 'MODULE_PATHNAME'
1070
LANGUAGE C IMMUTABLE STRICT;
1071

1072
CREATE FUNCTION gbt_cash_compress(internal)
1073
RETURNS internal
1074
AS 'MODULE_PATHNAME'
1075
LANGUAGE C IMMUTABLE STRICT;
1076

1077
CREATE FUNCTION gbt_cash_fetch(internal)
1078
RETURNS internal
1079
AS 'MODULE_PATHNAME'
1080
LANGUAGE C IMMUTABLE STRICT;
1081

1082
CREATE FUNCTION gbt_cash_penalty(internal,internal,internal)
1083
RETURNS internal
1084
AS 'MODULE_PATHNAME'
1085
LANGUAGE C IMMUTABLE STRICT;
1086

1087
CREATE FUNCTION gbt_cash_picksplit(internal, internal)
1088
RETURNS internal
1089
AS 'MODULE_PATHNAME'
1090
LANGUAGE C IMMUTABLE STRICT;
1091

1092
CREATE FUNCTION gbt_cash_union(internal, internal)
1093
RETURNS gbtreekey16
1094
AS 'MODULE_PATHNAME'
1095
LANGUAGE C IMMUTABLE STRICT;
1096

1097
CREATE FUNCTION gbt_cash_same(gbtreekey16, gbtreekey16, internal)
1098
RETURNS internal
1099
AS 'MODULE_PATHNAME'
1100
LANGUAGE C IMMUTABLE STRICT;
1101

1102
-- Create the operator class
1103
CREATE OPERATOR CLASS gist_cash_ops
1104
DEFAULT FOR TYPE money USING gist
1105
AS
1106
	OPERATOR	1	< ,
1107
	OPERATOR	2	<= ,
1108
	OPERATOR	3	= ,
1109
	OPERATOR	4	>= ,
1110
	OPERATOR	5	> ,
1111
	FUNCTION	1	gbt_cash_consistent (internal, money, int2, oid, internal),
1112
	FUNCTION	2	gbt_cash_union (internal, internal),
1113
	FUNCTION	3	gbt_cash_compress (internal),
1114
	FUNCTION	4	gbt_decompress (internal),
1115
	FUNCTION	5	gbt_cash_penalty (internal, internal, internal),
1116
	FUNCTION	6	gbt_cash_picksplit (internal, internal),
1117
	FUNCTION	7	gbt_cash_same (gbtreekey16, gbtreekey16, internal),
1118
	STORAGE		gbtreekey16;
1119

1120
ALTER OPERATOR FAMILY gist_cash_ops USING gist ADD
1121
	OPERATOR	6	<> (money, money) ,
1122
	OPERATOR	15	<-> (money, money) FOR ORDER BY pg_catalog.money_ops ,
1123
	FUNCTION	8 (money, money) gbt_cash_distance (internal, money, int2, oid, internal) ,
1124
	FUNCTION	9 (money, money) gbt_cash_fetch (internal) ;
1125

1126

1127
--
1128
--
1129
--
1130
-- macaddr ops
1131
--
1132
--
1133
--
1134
-- define the GiST support methods
1135
CREATE FUNCTION gbt_macad_consistent(internal,macaddr,int2,oid,internal)
1136
RETURNS bool
1137
AS 'MODULE_PATHNAME'
1138
LANGUAGE C IMMUTABLE STRICT;
1139

1140
CREATE FUNCTION gbt_macad_compress(internal)
1141
RETURNS internal
1142
AS 'MODULE_PATHNAME'
1143
LANGUAGE C IMMUTABLE STRICT;
1144

1145
CREATE FUNCTION gbt_macad_fetch(internal)
1146
RETURNS internal
1147
AS 'MODULE_PATHNAME'
1148
LANGUAGE C IMMUTABLE STRICT;
1149

1150
CREATE FUNCTION gbt_macad_penalty(internal,internal,internal)
1151
RETURNS internal
1152
AS 'MODULE_PATHNAME'
1153
LANGUAGE C IMMUTABLE STRICT;
1154

1155
CREATE FUNCTION gbt_macad_picksplit(internal, internal)
1156
RETURNS internal
1157
AS 'MODULE_PATHNAME'
1158
LANGUAGE C IMMUTABLE STRICT;
1159

1160
CREATE FUNCTION gbt_macad_union(internal, internal)
1161
RETURNS gbtreekey16
1162
AS 'MODULE_PATHNAME'
1163
LANGUAGE C IMMUTABLE STRICT;
1164

1165
CREATE FUNCTION gbt_macad_same(gbtreekey16, gbtreekey16, internal)
1166
RETURNS internal
1167
AS 'MODULE_PATHNAME'
1168
LANGUAGE C IMMUTABLE STRICT;
1169

1170
-- Create the operator class
1171
CREATE OPERATOR CLASS gist_macaddr_ops
1172
DEFAULT FOR TYPE macaddr USING gist
1173
AS
1174
	OPERATOR	1	< ,
1175
	OPERATOR	2	<= ,
1176
	OPERATOR	3	= ,
1177
	OPERATOR	4	>= ,
1178
	OPERATOR	5	> ,
1179
	FUNCTION	1	gbt_macad_consistent (internal, macaddr, int2, oid, internal),
1180
	FUNCTION	2	gbt_macad_union (internal, internal),
1181
	FUNCTION	3	gbt_macad_compress (internal),
1182
	FUNCTION	4	gbt_decompress (internal),
1183
	FUNCTION	5	gbt_macad_penalty (internal, internal, internal),
1184
	FUNCTION	6	gbt_macad_picksplit (internal, internal),
1185
	FUNCTION	7	gbt_macad_same (gbtreekey16, gbtreekey16, internal),
1186
	STORAGE		gbtreekey16;
1187

1188
ALTER OPERATOR FAMILY gist_macaddr_ops USING gist ADD
1189
	OPERATOR	6	<> (macaddr, macaddr) ,
1190
	FUNCTION	9 (macaddr, macaddr) gbt_macad_fetch (internal);
1191

1192

1193
--
1194
--
1195
--
1196
-- text/ bpchar ops
1197
--
1198
--
1199
--
1200
-- define the GiST support methods
1201
CREATE FUNCTION gbt_text_consistent(internal,text,int2,oid,internal)
1202
RETURNS bool
1203
AS 'MODULE_PATHNAME'
1204
LANGUAGE C IMMUTABLE STRICT;
1205

1206
CREATE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2,oid,internal)
1207
RETURNS bool
1208
AS 'MODULE_PATHNAME'
1209
LANGUAGE C IMMUTABLE STRICT;
1210

1211
CREATE FUNCTION gbt_text_compress(internal)
1212
RETURNS internal
1213
AS 'MODULE_PATHNAME'
1214
LANGUAGE C IMMUTABLE STRICT;
1215

1216
CREATE FUNCTION gbt_bpchar_compress(internal)
1217
RETURNS internal
1218
AS 'MODULE_PATHNAME'
1219
LANGUAGE C IMMUTABLE STRICT;
1220

1221
CREATE FUNCTION gbt_text_penalty(internal,internal,internal)
1222
RETURNS internal
1223
AS 'MODULE_PATHNAME'
1224
LANGUAGE C IMMUTABLE STRICT;
1225

1226
CREATE FUNCTION gbt_text_picksplit(internal, internal)
1227
RETURNS internal
1228
AS 'MODULE_PATHNAME'
1229
LANGUAGE C IMMUTABLE STRICT;
1230

1231
CREATE FUNCTION gbt_text_union(internal, internal)
1232
RETURNS gbtreekey_var
1233
AS 'MODULE_PATHNAME'
1234
LANGUAGE C IMMUTABLE STRICT;
1235

1236
CREATE FUNCTION gbt_text_same(gbtreekey_var, gbtreekey_var, internal)
1237
RETURNS internal
1238
AS 'MODULE_PATHNAME'
1239
LANGUAGE C IMMUTABLE STRICT;
1240

1241
-- Create the operator class
1242
CREATE OPERATOR CLASS gist_text_ops
1243
DEFAULT FOR TYPE text USING gist
1244
AS
1245
	OPERATOR	1	<  ,
1246
	OPERATOR	2	<= ,
1247
	OPERATOR	3	=  ,
1248
	OPERATOR	4	>= ,
1249
	OPERATOR	5	>  ,
1250
	FUNCTION	1	gbt_text_consistent (internal, text, int2, oid, internal),
1251
	FUNCTION	2	gbt_text_union (internal, internal),
1252
	FUNCTION	3	gbt_text_compress (internal),
1253
	FUNCTION	4	gbt_var_decompress (internal),
1254
	FUNCTION	5	gbt_text_penalty (internal, internal, internal),
1255
	FUNCTION	6	gbt_text_picksplit (internal, internal),
1256
	FUNCTION	7	gbt_text_same (gbtreekey_var, gbtreekey_var, internal),
1257
	STORAGE			gbtreekey_var;
1258

1259
ALTER OPERATOR FAMILY gist_text_ops USING gist ADD
1260
	OPERATOR	6	<> (text, text) ,
1261
	FUNCTION	9 (text, text) gbt_var_fetch (internal) ;
1262

1263

1264
---- Create the operator class
1265
CREATE OPERATOR CLASS gist_bpchar_ops
1266
DEFAULT FOR TYPE bpchar USING gist
1267
AS
1268
	OPERATOR	1	<  ,
1269
	OPERATOR	2	<= ,
1270
	OPERATOR	3	=  ,
1271
	OPERATOR	4	>= ,
1272
	OPERATOR	5	>  ,
1273
	FUNCTION	1	gbt_bpchar_consistent (internal, bpchar , int2, oid, internal),
1274
	FUNCTION	2	gbt_text_union (internal, internal),
1275
	FUNCTION	3	gbt_bpchar_compress (internal),
1276
	FUNCTION	4	gbt_var_decompress (internal),
1277
	FUNCTION	5	gbt_text_penalty (internal, internal, internal),
1278
	FUNCTION	6	gbt_text_picksplit (internal, internal),
1279
	FUNCTION	7	gbt_text_same (gbtreekey_var, gbtreekey_var, internal),
1280
	STORAGE			gbtreekey_var;
1281

1282
ALTER OPERATOR FAMILY gist_bpchar_ops USING gist ADD
1283
	OPERATOR	6	<> (bpchar, bpchar) ,
1284
	FUNCTION	9 (bpchar, bpchar) gbt_var_fetch (internal) ;
1285

1286
--
1287
--
1288
-- bytea ops
1289
--
1290
--
1291
--
1292
-- define the GiST support methods
1293
CREATE FUNCTION gbt_bytea_consistent(internal,bytea,int2,oid,internal)
1294
RETURNS bool
1295
AS 'MODULE_PATHNAME'
1296
LANGUAGE C IMMUTABLE STRICT;
1297

1298
CREATE FUNCTION gbt_bytea_compress(internal)
1299
RETURNS internal
1300
AS 'MODULE_PATHNAME'
1301
LANGUAGE C IMMUTABLE STRICT;
1302

1303
CREATE FUNCTION gbt_bytea_penalty(internal,internal,internal)
1304
RETURNS internal
1305
AS 'MODULE_PATHNAME'
1306
LANGUAGE C IMMUTABLE STRICT;
1307

1308
CREATE FUNCTION gbt_bytea_picksplit(internal, internal)
1309
RETURNS internal
1310
AS 'MODULE_PATHNAME'
1311
LANGUAGE C IMMUTABLE STRICT;
1312

1313
CREATE FUNCTION gbt_bytea_union(internal, internal)
1314
RETURNS gbtreekey_var
1315
AS 'MODULE_PATHNAME'
1316
LANGUAGE C IMMUTABLE STRICT;
1317

1318
CREATE FUNCTION gbt_bytea_same(gbtreekey_var, gbtreekey_var, internal)
1319
RETURNS internal
1320
AS 'MODULE_PATHNAME'
1321
LANGUAGE C IMMUTABLE STRICT;
1322

1323
-- Create the operator class
1324
CREATE OPERATOR CLASS gist_bytea_ops
1325
DEFAULT FOR TYPE bytea USING gist
1326
AS
1327
	OPERATOR	1	<  ,
1328
	OPERATOR	2	<= ,
1329
	OPERATOR	3	=  ,
1330
	OPERATOR	4	>= ,
1331
	OPERATOR	5	>  ,
1332
	FUNCTION	1	gbt_bytea_consistent (internal, bytea, int2, oid, internal),
1333
	FUNCTION	2	gbt_bytea_union (internal, internal),
1334
	FUNCTION	3	gbt_bytea_compress (internal),
1335
	FUNCTION	4	gbt_var_decompress (internal),
1336
	FUNCTION	5	gbt_bytea_penalty (internal, internal, internal),
1337
	FUNCTION	6	gbt_bytea_picksplit (internal, internal),
1338
	FUNCTION	7	gbt_bytea_same (gbtreekey_var, gbtreekey_var, internal),
1339
	STORAGE			gbtreekey_var;
1340

1341
ALTER OPERATOR FAMILY gist_bytea_ops USING gist ADD
1342
	OPERATOR	6	<> (bytea, bytea) ,
1343
	FUNCTION	9 (bytea, bytea) gbt_var_fetch (internal) ;
1344

1345

1346
--
1347
--
1348
--
1349
-- numeric ops
1350
--
1351
--
1352
--
1353
-- define the GiST support methods
1354
CREATE FUNCTION gbt_numeric_consistent(internal,numeric,int2,oid,internal)
1355
RETURNS bool
1356
AS 'MODULE_PATHNAME'
1357
LANGUAGE C IMMUTABLE STRICT;
1358

1359
CREATE FUNCTION gbt_numeric_compress(internal)
1360
RETURNS internal
1361
AS 'MODULE_PATHNAME'
1362
LANGUAGE C IMMUTABLE STRICT;
1363

1364
CREATE FUNCTION gbt_numeric_penalty(internal,internal,internal)
1365
RETURNS internal
1366
AS 'MODULE_PATHNAME'
1367
LANGUAGE C IMMUTABLE STRICT;
1368

1369
CREATE FUNCTION gbt_numeric_picksplit(internal, internal)
1370
RETURNS internal
1371
AS 'MODULE_PATHNAME'
1372
LANGUAGE C IMMUTABLE STRICT;
1373

1374
CREATE FUNCTION gbt_numeric_union(internal, internal)
1375
RETURNS gbtreekey_var
1376
AS 'MODULE_PATHNAME'
1377
LANGUAGE C IMMUTABLE STRICT;
1378

1379
CREATE FUNCTION gbt_numeric_same(gbtreekey_var, gbtreekey_var, internal)
1380
RETURNS internal
1381
AS 'MODULE_PATHNAME'
1382
LANGUAGE C IMMUTABLE STRICT;
1383

1384
-- Create the operator class
1385
CREATE OPERATOR CLASS gist_numeric_ops
1386
DEFAULT FOR TYPE numeric USING gist
1387
AS
1388
	OPERATOR	1	<  ,
1389
	OPERATOR	2	<= ,
1390
	OPERATOR	3	=  ,
1391
	OPERATOR	4	>= ,
1392
	OPERATOR	5	>  ,
1393
	FUNCTION	1	gbt_numeric_consistent (internal, numeric, int2, oid, internal),
1394
	FUNCTION	2	gbt_numeric_union (internal, internal),
1395
	FUNCTION	3	gbt_numeric_compress (internal),
1396
	FUNCTION	4	gbt_var_decompress (internal),
1397
	FUNCTION	5	gbt_numeric_penalty (internal, internal, internal),
1398
	FUNCTION	6	gbt_numeric_picksplit (internal, internal),
1399
	FUNCTION	7	gbt_numeric_same (gbtreekey_var, gbtreekey_var, internal),
1400
	STORAGE			gbtreekey_var;
1401

1402
ALTER OPERATOR FAMILY gist_numeric_ops USING gist ADD
1403
	OPERATOR	6	<> (numeric, numeric) ,
1404
	FUNCTION	9 (numeric, numeric) gbt_var_fetch (internal) ;
1405

1406

1407
--
1408
--
1409
-- bit ops
1410
--
1411
--
1412
--
1413
-- define the GiST support methods
1414
CREATE FUNCTION gbt_bit_consistent(internal,bit,int2,oid,internal)
1415
RETURNS bool
1416
AS 'MODULE_PATHNAME'
1417
LANGUAGE C IMMUTABLE STRICT;
1418

1419
CREATE FUNCTION gbt_bit_compress(internal)
1420
RETURNS internal
1421
AS 'MODULE_PATHNAME'
1422
LANGUAGE C IMMUTABLE STRICT;
1423

1424
CREATE FUNCTION gbt_bit_penalty(internal,internal,internal)
1425
RETURNS internal
1426
AS 'MODULE_PATHNAME'
1427
LANGUAGE C IMMUTABLE STRICT;
1428

1429
CREATE FUNCTION gbt_bit_picksplit(internal, internal)
1430
RETURNS internal
1431
AS 'MODULE_PATHNAME'
1432
LANGUAGE C IMMUTABLE STRICT;
1433

1434
CREATE FUNCTION gbt_bit_union(internal, internal)
1435
RETURNS gbtreekey_var
1436
AS 'MODULE_PATHNAME'
1437
LANGUAGE C IMMUTABLE STRICT;
1438

1439
CREATE FUNCTION gbt_bit_same(gbtreekey_var, gbtreekey_var, internal)
1440
RETURNS internal
1441
AS 'MODULE_PATHNAME'
1442
LANGUAGE C IMMUTABLE STRICT;
1443

1444
-- Create the operator class
1445
CREATE OPERATOR CLASS gist_bit_ops
1446
DEFAULT FOR TYPE bit USING gist
1447
AS
1448
	OPERATOR	1	<  ,
1449
	OPERATOR	2	<= ,
1450
	OPERATOR	3	=  ,
1451
	OPERATOR	4	>= ,
1452
	OPERATOR	5	>  ,
1453
	FUNCTION	1	gbt_bit_consistent (internal, bit, int2, oid, internal),
1454
	FUNCTION	2	gbt_bit_union (internal, internal),
1455
	FUNCTION	3	gbt_bit_compress (internal),
1456
	FUNCTION	4	gbt_var_decompress (internal),
1457
	FUNCTION	5	gbt_bit_penalty (internal, internal, internal),
1458
	FUNCTION	6	gbt_bit_picksplit (internal, internal),
1459
	FUNCTION	7	gbt_bit_same (gbtreekey_var, gbtreekey_var, internal),
1460
	STORAGE			gbtreekey_var;
1461

1462
ALTER OPERATOR FAMILY gist_bit_ops USING gist ADD
1463
	OPERATOR	6	<> (bit, bit) ,
1464
	FUNCTION	9 (bit, bit) gbt_var_fetch (internal) ;
1465

1466

1467
-- Create the operator class
1468
CREATE OPERATOR CLASS gist_vbit_ops
1469
DEFAULT FOR TYPE varbit USING gist
1470
AS
1471
	OPERATOR	1	<  ,
1472
	OPERATOR	2	<= ,
1473
	OPERATOR	3	=  ,
1474
	OPERATOR	4	>= ,
1475
	OPERATOR	5	>  ,
1476
	FUNCTION	1	gbt_bit_consistent (internal, bit, int2, oid, internal),
1477
	FUNCTION	2	gbt_bit_union (internal, internal),
1478
	FUNCTION	3	gbt_bit_compress (internal),
1479
	FUNCTION	4	gbt_var_decompress (internal),
1480
	FUNCTION	5	gbt_bit_penalty (internal, internal, internal),
1481
	FUNCTION	6	gbt_bit_picksplit (internal, internal),
1482
	FUNCTION	7	gbt_bit_same (gbtreekey_var, gbtreekey_var, internal),
1483
	STORAGE			gbtreekey_var;
1484

1485
ALTER OPERATOR FAMILY gist_vbit_ops USING gist ADD
1486
	OPERATOR	6	<> (varbit, varbit) ,
1487
	FUNCTION	9 (varbit, varbit) gbt_var_fetch (internal) ;
1488

1489

1490
--
1491
--
1492
--
1493
-- inet/cidr ops
1494
--
1495
--
1496
--
1497
-- define the GiST support methods
1498
CREATE FUNCTION gbt_inet_consistent(internal,inet,int2,oid,internal)
1499
RETURNS bool
1500
AS 'MODULE_PATHNAME'
1501
LANGUAGE C IMMUTABLE STRICT;
1502

1503
CREATE FUNCTION gbt_inet_compress(internal)
1504
RETURNS internal
1505
AS 'MODULE_PATHNAME'
1506
LANGUAGE C IMMUTABLE STRICT;
1507

1508
CREATE FUNCTION gbt_inet_penalty(internal,internal,internal)
1509
RETURNS internal
1510
AS 'MODULE_PATHNAME'
1511
LANGUAGE C IMMUTABLE STRICT;
1512

1513
CREATE FUNCTION gbt_inet_picksplit(internal, internal)
1514
RETURNS internal
1515
AS 'MODULE_PATHNAME'
1516
LANGUAGE C IMMUTABLE STRICT;
1517

1518
CREATE FUNCTION gbt_inet_union(internal, internal)
1519
RETURNS gbtreekey16
1520
AS 'MODULE_PATHNAME'
1521
LANGUAGE C IMMUTABLE STRICT;
1522

1523
CREATE FUNCTION gbt_inet_same(gbtreekey16, gbtreekey16, internal)
1524
RETURNS internal
1525
AS 'MODULE_PATHNAME'
1526
LANGUAGE C IMMUTABLE STRICT;
1527

1528
-- Create the operator class
1529
CREATE OPERATOR CLASS gist_inet_ops
1530
DEFAULT FOR TYPE inet USING gist
1531
AS
1532
	OPERATOR	1	<   ,
1533
	OPERATOR	2	<=  ,
1534
	OPERATOR	3	=   ,
1535
	OPERATOR	4	>=  ,
1536
	OPERATOR	5	>   ,
1537
	FUNCTION	1	gbt_inet_consistent (internal, inet, int2, oid, internal),
1538
	FUNCTION	2	gbt_inet_union (internal, internal),
1539
	FUNCTION	3	gbt_inet_compress (internal),
1540
	FUNCTION	4	gbt_decompress (internal),
1541
	FUNCTION	5	gbt_inet_penalty (internal, internal, internal),
1542
	FUNCTION	6	gbt_inet_picksplit (internal, internal),
1543
	FUNCTION	7	gbt_inet_same (gbtreekey16, gbtreekey16, internal),
1544
	STORAGE		gbtreekey16;
1545

1546
ALTER OPERATOR FAMILY gist_inet_ops USING gist ADD
1547
	OPERATOR	6	<>  (inet, inet) ;
1548
	-- no fetch support, the compress function is lossy
1549

1550
-- Create the operator class
1551
CREATE OPERATOR CLASS gist_cidr_ops
1552
DEFAULT FOR TYPE cidr USING gist
1553
AS
1554
	OPERATOR	1	<  (inet, inet)  ,
1555
	OPERATOR	2	<= (inet, inet)  ,
1556
	OPERATOR	3	=  (inet, inet)  ,
1557
	OPERATOR	4	>= (inet, inet)  ,
1558
	OPERATOR	5	>  (inet, inet)  ,
1559
	FUNCTION	1	gbt_inet_consistent (internal, inet, int2, oid, internal),
1560
	FUNCTION	2	gbt_inet_union (internal, internal),
1561
	FUNCTION	3	gbt_inet_compress (internal),
1562
	FUNCTION	4	gbt_decompress (internal),
1563
	FUNCTION	5	gbt_inet_penalty (internal, internal, internal),
1564
	FUNCTION	6	gbt_inet_picksplit (internal, internal),
1565
	FUNCTION	7	gbt_inet_same (gbtreekey16, gbtreekey16, internal),
1566
	STORAGE		gbtreekey16;
1567

1568
ALTER OPERATOR FAMILY gist_cidr_ops USING gist ADD
1569
	OPERATOR	6	<> (inet, inet) ;
1570
	-- no fetch support, the compress function is lossy
1571