← Back to branch summary

~ubuntu-branches/ubuntu/trusty/postgresql-8.4/trusty

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2009-07-11 16:59:35 UTC
  • mfrom: (5.1.1 karmic)
  • Revision ID: james.westby@ubuntu.com-20090711165935-jfwin6gfrxf0gfsi
Tags: 8.4.0-2
http://bugs.debian.org/536139
* debian/libpq-dev.install: Ship catalog/genbki.h. (Closes: #536139)
* debian/rules: Drop --enable-cassert for final release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/btree_gist/btree_gist.sql.in
1
 
/* $PostgreSQL: pgsql/contrib/btree_gist/btree_gist.sql.in,v 1.20 2008/04/14 17:05:31 tgl Exp $ */
 
1
/* $PostgreSQL: pgsql/contrib/btree_gist/btree_gist.sql.in,v 1.21 2009/06/11 18:30:03 tgl Exp $ */
2
2
 
3
3
-- Adjust this setting to control where the objects get created.
4
4
SET search_path = public;
97
97
CREATE OR REPLACE FUNCTION gbt_oid_consistent(internal,oid,int2,oid,internal)
98
98
RETURNS bool
99
99
AS 'MODULE_PATHNAME'
100
 
LANGUAGE C IMMUTABLE;
 
100
LANGUAGE C IMMUTABLE STRICT;
101
101
 
102
102
CREATE OR REPLACE FUNCTION gbt_oid_compress(internal)
103
103
RETURNS internal
104
104
AS 'MODULE_PATHNAME'
105
 
LANGUAGE C IMMUTABLE;
 
105
LANGUAGE C IMMUTABLE STRICT;
106
106
 
107
107
CREATE OR REPLACE FUNCTION gbt_decompress(internal)
108
108
RETURNS internal
109
109
AS 'MODULE_PATHNAME'
110
 
LANGUAGE C IMMUTABLE;
 
110
LANGUAGE C IMMUTABLE STRICT;
111
111
 
112
112
CREATE OR REPLACE FUNCTION gbt_var_decompress(internal)
113
113
RETURNS internal
114
114
AS 'MODULE_PATHNAME'
115
 
LANGUAGE C IMMUTABLE;
 
115
LANGUAGE C IMMUTABLE STRICT;
116
116
 
117
117
CREATE OR REPLACE FUNCTION gbt_oid_penalty(internal,internal,internal)
118
118
RETURNS internal
122
122
CREATE OR REPLACE FUNCTION gbt_oid_picksplit(internal, internal)
123
123
RETURNS internal
124
124
AS 'MODULE_PATHNAME'
125
 
LANGUAGE C IMMUTABLE;
 
125
LANGUAGE C IMMUTABLE STRICT;
126
126
 
127
127
CREATE OR REPLACE FUNCTION gbt_oid_union(bytea, internal)
128
128
RETURNS gbtreekey8
129
129
AS 'MODULE_PATHNAME'
130
 
LANGUAGE C IMMUTABLE;
 
130
LANGUAGE C IMMUTABLE STRICT;
131
131
 
132
132
CREATE OR REPLACE FUNCTION gbt_oid_same(internal, internal, internal)
133
133
RETURNS internal
134
134
AS 'MODULE_PATHNAME'
135
 
LANGUAGE C IMMUTABLE;
 
135
LANGUAGE C IMMUTABLE STRICT;
136
136
 
137
137
-- Create the operator class
138
138
CREATE OPERATOR CLASS gist_oid_ops
164
164
CREATE OR REPLACE FUNCTION gbt_int2_consistent(internal,int2,int2,oid,internal)
165
165
RETURNS bool
166
166
AS 'MODULE_PATHNAME'
167
 
LANGUAGE C IMMUTABLE;
 
167
LANGUAGE C IMMUTABLE STRICT;
168
168
 
169
169
CREATE OR REPLACE FUNCTION gbt_int2_compress(internal)
170
170
RETURNS internal
171
171
AS 'MODULE_PATHNAME'
172
 
LANGUAGE C IMMUTABLE;
 
172
LANGUAGE C IMMUTABLE STRICT;
173
173
 
174
174
CREATE OR REPLACE FUNCTION gbt_int2_penalty(internal,internal,internal)
175
175
RETURNS internal
179
179
CREATE OR REPLACE FUNCTION gbt_int2_picksplit(internal, internal)
180
180
RETURNS internal
181
181
AS 'MODULE_PATHNAME'
182
 
LANGUAGE C IMMUTABLE;
 
182
LANGUAGE C IMMUTABLE STRICT;
183
183
 
184
184
CREATE OR REPLACE FUNCTION gbt_int2_union(bytea, internal)
185
185
RETURNS gbtreekey4
186
186
AS 'MODULE_PATHNAME'
187
 
LANGUAGE C IMMUTABLE;
 
187
LANGUAGE C IMMUTABLE STRICT;
188
188
 
189
189
CREATE OR REPLACE FUNCTION gbt_int2_same(internal, internal, internal)
190
190
RETURNS internal
191
191
AS 'MODULE_PATHNAME'
192
 
LANGUAGE C IMMUTABLE;
 
192
LANGUAGE C IMMUTABLE STRICT;
193
193
 
194
194
-- Create the operator class
195
195
CREATE OPERATOR CLASS gist_int2_ops
220
220
CREATE OR REPLACE FUNCTION gbt_int4_consistent(internal,int4,int2,oid,internal)
221
221
RETURNS bool
222
222
AS 'MODULE_PATHNAME'
223
 
LANGUAGE C IMMUTABLE;
 
223
LANGUAGE C IMMUTABLE STRICT;
224
224
 
225
225
CREATE OR REPLACE FUNCTION gbt_int4_compress(internal)
226
226
RETURNS internal
227
227
AS 'MODULE_PATHNAME'
228
 
LANGUAGE C IMMUTABLE;
 
228
LANGUAGE C IMMUTABLE STRICT;
229
229
 
230
230
CREATE OR REPLACE FUNCTION gbt_int4_penalty(internal,internal,internal)
231
231
RETURNS internal
235
235
CREATE OR REPLACE FUNCTION gbt_int4_picksplit(internal, internal)
236
236
RETURNS internal
237
237
AS 'MODULE_PATHNAME'
238
 
LANGUAGE C IMMUTABLE;
 
238
LANGUAGE C IMMUTABLE STRICT;
239
239
 
240
240
CREATE OR REPLACE FUNCTION gbt_int4_union(bytea, internal)
241
241
RETURNS gbtreekey8
242
242
AS 'MODULE_PATHNAME'
243
 
LANGUAGE C IMMUTABLE;
 
243
LANGUAGE C IMMUTABLE STRICT;
244
244
 
245
245
CREATE OR REPLACE FUNCTION gbt_int4_same(internal, internal, internal)
246
246
RETURNS internal
247
247
AS 'MODULE_PATHNAME'
248
 
LANGUAGE C IMMUTABLE;
 
248
LANGUAGE C IMMUTABLE STRICT;
249
249
 
250
250
-- Create the operator class
251
251
CREATE OPERATOR CLASS gist_int4_ops
276
276
CREATE OR REPLACE FUNCTION gbt_int8_consistent(internal,int8,int2,oid,internal)
277
277
RETURNS bool
278
278
AS 'MODULE_PATHNAME'
279
 
LANGUAGE C IMMUTABLE;
 
279
LANGUAGE C IMMUTABLE STRICT;
280
280
 
281
281
CREATE OR REPLACE FUNCTION gbt_int8_compress(internal)
282
282
RETURNS internal
283
283
AS 'MODULE_PATHNAME'
284
 
LANGUAGE C IMMUTABLE;
 
284
LANGUAGE C IMMUTABLE STRICT;
285
285
 
286
286
CREATE OR REPLACE FUNCTION gbt_int8_penalty(internal,internal,internal)
287
287
RETURNS internal
291
291
CREATE OR REPLACE FUNCTION gbt_int8_picksplit(internal, internal)
292
292
RETURNS internal
293
293
AS 'MODULE_PATHNAME'
294
 
LANGUAGE C IMMUTABLE;
 
294
LANGUAGE C IMMUTABLE STRICT;
295
295
 
296
296
CREATE OR REPLACE FUNCTION gbt_int8_union(bytea, internal)
297
297
RETURNS gbtreekey16
298
298
AS 'MODULE_PATHNAME'
299
 
LANGUAGE C IMMUTABLE;
 
299
LANGUAGE C IMMUTABLE STRICT;
300
300
 
301
301
CREATE OR REPLACE FUNCTION gbt_int8_same(internal, internal, internal)
302
302
RETURNS internal
303
303
AS 'MODULE_PATHNAME'
304
 
LANGUAGE C IMMUTABLE;
 
304
LANGUAGE C IMMUTABLE STRICT;
305
305
 
306
306
-- Create the operator class
307
307
CREATE OPERATOR CLASS gist_int8_ops
333
333
CREATE OR REPLACE FUNCTION gbt_float4_consistent(internal,float4,int2,oid,internal)
334
334
RETURNS bool
335
335
AS 'MODULE_PATHNAME'
336
 
LANGUAGE C IMMUTABLE;
 
336
LANGUAGE C IMMUTABLE STRICT;
337
337
 
338
338
CREATE OR REPLACE FUNCTION gbt_float4_compress(internal)
339
339
RETURNS internal
340
340
AS 'MODULE_PATHNAME'
341
 
LANGUAGE C IMMUTABLE;
 
341
LANGUAGE C IMMUTABLE STRICT;
342
342
 
343
343
CREATE OR REPLACE FUNCTION gbt_float4_penalty(internal,internal,internal)
344
344
RETURNS internal
348
348
CREATE OR REPLACE FUNCTION gbt_float4_picksplit(internal, internal)
349
349
RETURNS internal
350
350
AS 'MODULE_PATHNAME'
351
 
LANGUAGE C IMMUTABLE;
 
351
LANGUAGE C IMMUTABLE STRICT;
352
352
 
353
353
CREATE OR REPLACE FUNCTION gbt_float4_union(bytea, internal)
354
354
RETURNS gbtreekey8
355
355
AS 'MODULE_PATHNAME'
356
 
LANGUAGE C IMMUTABLE;
 
356
LANGUAGE C IMMUTABLE STRICT;
357
357
 
358
358
CREATE OR REPLACE FUNCTION gbt_float4_same(internal, internal, internal)
359
359
RETURNS internal
360
360
AS 'MODULE_PATHNAME'
361
 
LANGUAGE C IMMUTABLE;
 
361
LANGUAGE C IMMUTABLE STRICT;
362
362
 
363
363
-- Create the operator class
364
364
CREATE OPERATOR CLASS gist_float4_ops
392
392
CREATE OR REPLACE FUNCTION gbt_float8_consistent(internal,float8,int2,oid,internal)
393
393
RETURNS bool
394
394
AS 'MODULE_PATHNAME'
395
 
LANGUAGE C IMMUTABLE;
 
395
LANGUAGE C IMMUTABLE STRICT;
396
396
 
397
397
CREATE OR REPLACE FUNCTION gbt_float8_compress(internal)
398
398
RETURNS internal
399
399
AS 'MODULE_PATHNAME'
400
 
LANGUAGE C IMMUTABLE;
 
400
LANGUAGE C IMMUTABLE STRICT;
401
401
 
402
402
CREATE OR REPLACE FUNCTION gbt_float8_penalty(internal,internal,internal)
403
403
RETURNS internal
407
407
CREATE OR REPLACE FUNCTION gbt_float8_picksplit(internal, internal)
408
408
RETURNS internal
409
409
AS 'MODULE_PATHNAME'
410
 
LANGUAGE C IMMUTABLE;
 
410
LANGUAGE C IMMUTABLE STRICT;
411
411
 
412
412
CREATE OR REPLACE FUNCTION gbt_float8_union(bytea, internal)
413
413
RETURNS gbtreekey16
414
414
AS 'MODULE_PATHNAME'
415
 
LANGUAGE C IMMUTABLE;
 
415
LANGUAGE C IMMUTABLE STRICT;
416
416
 
417
417
CREATE OR REPLACE FUNCTION gbt_float8_same(internal, internal, internal)
418
418
RETURNS internal
419
419
AS 'MODULE_PATHNAME'
420
 
LANGUAGE C IMMUTABLE;
 
420
LANGUAGE C IMMUTABLE STRICT;
421
421
 
422
422
-- Create the operator class
423
423
CREATE OPERATOR CLASS gist_float8_ops
449
449
CREATE OR REPLACE FUNCTION gbt_ts_consistent(internal,timestamp,int2,oid,internal)
450
450
RETURNS bool
451
451
AS 'MODULE_PATHNAME'
452
 
LANGUAGE C IMMUTABLE;
 
452
LANGUAGE C IMMUTABLE STRICT;
453
453
 
454
454
CREATE OR REPLACE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2,oid,internal)
455
455
RETURNS bool
456
456
AS 'MODULE_PATHNAME'
457
 
LANGUAGE C IMMUTABLE;
 
457
LANGUAGE C IMMUTABLE STRICT;
458
458
      
459
459
CREATE OR REPLACE FUNCTION gbt_ts_compress(internal)
460
460
RETURNS internal
461
461
AS 'MODULE_PATHNAME'
462
 
LANGUAGE C IMMUTABLE;
 
462
LANGUAGE C IMMUTABLE STRICT;
463
463
 
464
464
CREATE OR REPLACE FUNCTION gbt_tstz_compress(internal)
465
465
RETURNS internal
466
466
AS 'MODULE_PATHNAME'
467
 
LANGUAGE C IMMUTABLE;
 
467
LANGUAGE C IMMUTABLE STRICT;
468
468
 
469
469
CREATE OR REPLACE FUNCTION gbt_ts_penalty(internal,internal,internal)
470
470
RETURNS internal
474
474
CREATE OR REPLACE FUNCTION gbt_ts_picksplit(internal, internal)
475
475
RETURNS internal
476
476
AS 'MODULE_PATHNAME'
477
 
LANGUAGE C IMMUTABLE;
 
477
LANGUAGE C IMMUTABLE STRICT;
478
478
      
479
479
CREATE OR REPLACE FUNCTION gbt_ts_union(bytea, internal)
480
480
RETURNS gbtreekey16
481
481
AS 'MODULE_PATHNAME'
482
 
LANGUAGE C IMMUTABLE;
 
482
LANGUAGE C IMMUTABLE STRICT;
483
483
 
484
484
CREATE OR REPLACE FUNCTION gbt_ts_same(internal, internal, internal)
485
485
RETURNS internal
486
486
AS 'MODULE_PATHNAME'
487
 
LANGUAGE C IMMUTABLE;
 
487
LANGUAGE C IMMUTABLE STRICT;
488
488
 
489
489
-- Create the operator class
490
490
CREATE OPERATOR CLASS gist_timestamp_ops
535
535
CREATE OR REPLACE FUNCTION gbt_time_consistent(internal,time,int2,oid,internal)
536
536
RETURNS bool
537
537
AS 'MODULE_PATHNAME'
538
 
LANGUAGE C IMMUTABLE;
 
538
LANGUAGE C IMMUTABLE STRICT;
539
539
 
540
540
CREATE OR REPLACE FUNCTION gbt_timetz_consistent(internal,timetz,int2,oid,internal)
541
541
RETURNS bool
542
542
AS 'MODULE_PATHNAME'
543
 
LANGUAGE C IMMUTABLE;
 
543
LANGUAGE C IMMUTABLE STRICT;
544
544
 
545
545
CREATE OR REPLACE FUNCTION gbt_time_compress(internal)
546
546
RETURNS internal
547
547
AS 'MODULE_PATHNAME'
548
 
LANGUAGE C IMMUTABLE;
 
548
LANGUAGE C IMMUTABLE STRICT;
549
549
 
550
550
CREATE OR REPLACE FUNCTION gbt_timetz_compress(internal)
551
551
RETURNS internal
552
552
AS 'MODULE_PATHNAME'
553
 
LANGUAGE C IMMUTABLE;
 
553
LANGUAGE C IMMUTABLE STRICT;
554
554
 
555
555
CREATE OR REPLACE FUNCTION gbt_time_penalty(internal,internal,internal)
556
556
RETURNS internal
560
560
CREATE OR REPLACE FUNCTION gbt_time_picksplit(internal, internal)
561
561
RETURNS internal
562
562
AS 'MODULE_PATHNAME'
563
 
LANGUAGE C IMMUTABLE;
 
563
LANGUAGE C IMMUTABLE STRICT;
564
564
      
565
565
CREATE OR REPLACE FUNCTION gbt_time_union(bytea, internal)
566
566
RETURNS gbtreekey16
567
567
AS 'MODULE_PATHNAME'
568
 
LANGUAGE C IMMUTABLE;
 
568
LANGUAGE C IMMUTABLE STRICT;
569
569
 
570
570
CREATE OR REPLACE FUNCTION gbt_time_same(internal, internal, internal)
571
571
RETURNS internal
572
572
AS 'MODULE_PATHNAME'
573
 
LANGUAGE C IMMUTABLE;
 
573
LANGUAGE C IMMUTABLE STRICT;
574
574
 
575
575
-- Create the operator class
576
576
CREATE OPERATOR CLASS gist_time_ops
619
619
CREATE OR REPLACE FUNCTION gbt_date_consistent(internal,date,int2,oid,internal)
620
620
RETURNS bool
621
621
AS 'MODULE_PATHNAME'
622
 
LANGUAGE C IMMUTABLE;
 
622
LANGUAGE C IMMUTABLE STRICT;
623
623
 
624
624
CREATE OR REPLACE FUNCTION gbt_date_compress(internal)
625
625
RETURNS internal
626
626
AS 'MODULE_PATHNAME'
627
 
LANGUAGE C IMMUTABLE;
 
627
LANGUAGE C IMMUTABLE STRICT;
628
628
 
629
629
CREATE OR REPLACE FUNCTION gbt_date_penalty(internal,internal,internal)
630
630
RETURNS internal
634
634
CREATE OR REPLACE FUNCTION gbt_date_picksplit(internal, internal)
635
635
RETURNS internal
636
636
AS 'MODULE_PATHNAME'
637
 
LANGUAGE C IMMUTABLE;
 
637
LANGUAGE C IMMUTABLE STRICT;
638
638
      
639
639
CREATE OR REPLACE FUNCTION gbt_date_union(bytea, internal)
640
640
RETURNS gbtreekey8
641
641
AS 'MODULE_PATHNAME'
642
 
LANGUAGE C IMMUTABLE;
 
642
LANGUAGE C IMMUTABLE STRICT;
643
643
 
644
644
CREATE OR REPLACE FUNCTION gbt_date_same(internal, internal, internal)
645
645
RETURNS internal
646
646
AS 'MODULE_PATHNAME'
647
 
LANGUAGE C IMMUTABLE;
 
647
LANGUAGE C IMMUTABLE STRICT;
648
648
 
649
649
-- Create the operator class
650
650
CREATE OPERATOR CLASS gist_date_ops
676
676
CREATE OR REPLACE FUNCTION gbt_intv_consistent(internal,interval,int2,oid,internal)
677
677
RETURNS bool
678
678
AS 'MODULE_PATHNAME'
679
 
LANGUAGE C IMMUTABLE;
 
679
LANGUAGE C IMMUTABLE STRICT;
680
680
 
681
681
CREATE OR REPLACE FUNCTION gbt_intv_compress(internal)
682
682
RETURNS internal
683
683
AS 'MODULE_PATHNAME'
684
 
LANGUAGE C IMMUTABLE;
 
684
LANGUAGE C IMMUTABLE STRICT;
685
685
 
686
686
CREATE OR REPLACE FUNCTION gbt_intv_decompress(internal)
687
687
RETURNS internal
688
688
AS 'MODULE_PATHNAME'
689
 
LANGUAGE C IMMUTABLE;
 
689
LANGUAGE C IMMUTABLE STRICT;
690
690
 
691
691
CREATE OR REPLACE FUNCTION gbt_intv_penalty(internal,internal,internal)
692
692
RETURNS internal
696
696
CREATE OR REPLACE FUNCTION gbt_intv_picksplit(internal, internal)
697
697
RETURNS internal
698
698
AS 'MODULE_PATHNAME'
699
 
LANGUAGE C IMMUTABLE;
 
699
LANGUAGE C IMMUTABLE STRICT;
700
700
      
701
701
CREATE OR REPLACE FUNCTION gbt_intv_union(bytea, internal)
702
702
RETURNS gbtreekey32
703
703
AS 'MODULE_PATHNAME'
704
 
LANGUAGE C IMMUTABLE;
 
704
LANGUAGE C IMMUTABLE STRICT;
705
705
 
706
706
CREATE OR REPLACE FUNCTION gbt_intv_same(internal, internal, internal)
707
707
RETURNS internal
708
708
AS 'MODULE_PATHNAME'
709
 
LANGUAGE C IMMUTABLE;
 
709
LANGUAGE C IMMUTABLE STRICT;
710
710
 
711
711
-- Create the operator class
712
712
CREATE OPERATOR CLASS gist_interval_ops
737
737
CREATE OR REPLACE FUNCTION gbt_cash_consistent(internal,money,int2,oid,internal)
738
738
RETURNS bool
739
739
AS 'MODULE_PATHNAME'
740
 
LANGUAGE C IMMUTABLE;
 
740
LANGUAGE C IMMUTABLE STRICT;
741
741
 
742
742
CREATE OR REPLACE FUNCTION gbt_cash_compress(internal)
743
743
RETURNS internal
744
744
AS 'MODULE_PATHNAME'
745
 
LANGUAGE C IMMUTABLE;
 
745
LANGUAGE C IMMUTABLE STRICT;
746
746
 
747
747
CREATE OR REPLACE FUNCTION gbt_cash_penalty(internal,internal,internal)
748
748
RETURNS internal
752
752
CREATE OR REPLACE FUNCTION gbt_cash_picksplit(internal, internal)
753
753
RETURNS internal
754
754
AS 'MODULE_PATHNAME'
755
 
LANGUAGE C IMMUTABLE;
 
755
LANGUAGE C IMMUTABLE STRICT;
756
756
 
757
757
CREATE OR REPLACE FUNCTION gbt_cash_union(bytea, internal)
758
758
RETURNS gbtreekey8
759
759
AS 'MODULE_PATHNAME'
760
 
LANGUAGE C IMMUTABLE;
 
760
LANGUAGE C IMMUTABLE STRICT;
761
761
 
762
762
CREATE OR REPLACE FUNCTION gbt_cash_same(internal, internal, internal)
763
763
RETURNS internal
764
764
AS 'MODULE_PATHNAME'
765
 
LANGUAGE C IMMUTABLE;
 
765
LANGUAGE C IMMUTABLE STRICT;
766
766
 
767
767
-- Create the operator class
768
768
CREATE OPERATOR CLASS gist_cash_ops
793
793
CREATE OR REPLACE FUNCTION gbt_macad_consistent(internal,macaddr,int2,oid,internal)
794
794
RETURNS bool
795
795
AS 'MODULE_PATHNAME'
796
 
LANGUAGE C IMMUTABLE;
 
796
LANGUAGE C IMMUTABLE STRICT;
797
797
 
798
798
CREATE OR REPLACE FUNCTION gbt_macad_compress(internal)
799
799
RETURNS internal
800
800
AS 'MODULE_PATHNAME'
801
 
LANGUAGE C IMMUTABLE;
 
801
LANGUAGE C IMMUTABLE STRICT;
802
802
 
803
803
CREATE OR REPLACE FUNCTION gbt_macad_penalty(internal,internal,internal)
804
804
RETURNS internal
808
808
CREATE OR REPLACE FUNCTION gbt_macad_picksplit(internal, internal)
809
809
RETURNS internal
810
810
AS 'MODULE_PATHNAME'
811
 
LANGUAGE C IMMUTABLE;
 
811
LANGUAGE C IMMUTABLE STRICT;
812
812
 
813
813
CREATE OR REPLACE FUNCTION gbt_macad_union(bytea, internal)
814
814
RETURNS gbtreekey16
815
815
AS 'MODULE_PATHNAME'
816
 
LANGUAGE C IMMUTABLE;
 
816
LANGUAGE C IMMUTABLE STRICT;
817
817
 
818
818
CREATE OR REPLACE FUNCTION gbt_macad_same(internal, internal, internal)
819
819
RETURNS internal
820
820
AS 'MODULE_PATHNAME'
821
 
LANGUAGE C IMMUTABLE;
 
821
LANGUAGE C IMMUTABLE STRICT;
822
822
 
823
823
-- Create the operator class
824
824
CREATE OPERATOR CLASS gist_macaddr_ops
851
851
CREATE OR REPLACE FUNCTION gbt_text_consistent(internal,text,int2,oid,internal)
852
852
RETURNS bool
853
853
AS 'MODULE_PATHNAME'
854
 
LANGUAGE C IMMUTABLE;
 
854
LANGUAGE C IMMUTABLE STRICT;
855
855
 
856
856
CREATE OR REPLACE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2,oid,internal)
857
857
RETURNS bool
858
858
AS 'MODULE_PATHNAME'
859
 
LANGUAGE C IMMUTABLE;
 
859
LANGUAGE C IMMUTABLE STRICT;
860
860
 
861
861
CREATE OR REPLACE FUNCTION gbt_text_compress(internal)
862
862
RETURNS internal
863
863
AS 'MODULE_PATHNAME'
864
 
LANGUAGE C IMMUTABLE;
 
864
LANGUAGE C IMMUTABLE STRICT;
865
865
 
866
866
CREATE OR REPLACE FUNCTION gbt_bpchar_compress(internal)
867
867
RETURNS internal
868
868
AS 'MODULE_PATHNAME'
869
 
LANGUAGE C IMMUTABLE;
 
869
LANGUAGE C IMMUTABLE STRICT;
870
870
 
871
871
CREATE OR REPLACE FUNCTION gbt_text_penalty(internal,internal,internal)
872
872
RETURNS internal
876
876
CREATE OR REPLACE FUNCTION gbt_text_picksplit(internal, internal)
877
877
RETURNS internal
878
878
AS 'MODULE_PATHNAME'
879
 
LANGUAGE C IMMUTABLE;
 
879
LANGUAGE C IMMUTABLE STRICT;
880
880
 
881
881
CREATE OR REPLACE FUNCTION gbt_text_union(bytea, internal)
882
882
RETURNS gbtreekey_var
883
883
AS 'MODULE_PATHNAME'
884
 
LANGUAGE C IMMUTABLE;
 
884
LANGUAGE C IMMUTABLE STRICT;
885
885
 
886
886
CREATE OR REPLACE FUNCTION gbt_text_same(internal, internal, internal)
887
887
RETURNS internal
888
888
AS 'MODULE_PATHNAME'
889
 
LANGUAGE C IMMUTABLE;
 
889
LANGUAGE C IMMUTABLE STRICT;
890
890
 
891
891
-- Create the operator class
892
892
CREATE OPERATOR CLASS gist_text_ops
937
937
CREATE OR REPLACE FUNCTION gbt_bytea_consistent(internal,bytea,int2,oid,internal)
938
938
RETURNS bool
939
939
AS 'MODULE_PATHNAME'
940
 
LANGUAGE C IMMUTABLE;
 
940
LANGUAGE C IMMUTABLE STRICT;
941
941
 
942
942
CREATE OR REPLACE FUNCTION gbt_bytea_compress(internal)
943
943
RETURNS internal
944
944
AS 'MODULE_PATHNAME'
945
 
LANGUAGE C IMMUTABLE;
 
945
LANGUAGE C IMMUTABLE STRICT;
946
946
 
947
947
CREATE OR REPLACE FUNCTION gbt_bytea_penalty(internal,internal,internal)
948
948
RETURNS internal
952
952
CREATE OR REPLACE FUNCTION gbt_bytea_picksplit(internal, internal)
953
953
RETURNS internal
954
954
AS 'MODULE_PATHNAME'
955
 
LANGUAGE C IMMUTABLE;
 
955
LANGUAGE C IMMUTABLE STRICT;
956
956
 
957
957
CREATE OR REPLACE FUNCTION gbt_bytea_union(bytea, internal)
958
958
RETURNS gbtreekey_var
959
959
AS 'MODULE_PATHNAME'
960
 
LANGUAGE C IMMUTABLE;
 
960
LANGUAGE C IMMUTABLE STRICT;
961
961
 
962
962
CREATE OR REPLACE FUNCTION gbt_bytea_same(internal, internal, internal)
963
963
RETURNS internal
964
964
AS 'MODULE_PATHNAME'
965
 
LANGUAGE C IMMUTABLE;
 
965
LANGUAGE C IMMUTABLE STRICT;
966
966
 
967
967
-- Create the operator class
968
968
CREATE OPERATOR CLASS gist_bytea_ops
994
994
CREATE OR REPLACE FUNCTION gbt_numeric_consistent(internal,numeric,int2,oid,internal)
995
995
RETURNS bool
996
996
AS 'MODULE_PATHNAME'
997
 
LANGUAGE C IMMUTABLE;
 
997
LANGUAGE C IMMUTABLE STRICT;
998
998
 
999
999
CREATE OR REPLACE FUNCTION gbt_numeric_compress(internal)
1000
1000
RETURNS internal
1001
1001
AS 'MODULE_PATHNAME'
1002
 
LANGUAGE C IMMUTABLE;
 
1002
LANGUAGE C IMMUTABLE STRICT;
1003
1003
 
1004
1004
CREATE OR REPLACE FUNCTION gbt_numeric_penalty(internal,internal,internal)
1005
1005
RETURNS internal
1009
1009
CREATE OR REPLACE FUNCTION gbt_numeric_picksplit(internal, internal)
1010
1010
RETURNS internal
1011
1011
AS 'MODULE_PATHNAME'
1012
 
LANGUAGE C IMMUTABLE;
 
1012
LANGUAGE C IMMUTABLE STRICT;
1013
1013
 
1014
1014
CREATE OR REPLACE FUNCTION gbt_numeric_union(bytea, internal)
1015
1015
RETURNS gbtreekey_var
1016
1016
AS 'MODULE_PATHNAME'
1017
 
LANGUAGE C IMMUTABLE;
 
1017
LANGUAGE C IMMUTABLE STRICT;
1018
1018
 
1019
1019
CREATE OR REPLACE FUNCTION gbt_numeric_same(internal, internal, internal)
1020
1020
RETURNS internal
1021
1021
AS 'MODULE_PATHNAME'
1022
 
LANGUAGE C IMMUTABLE;
 
1022
LANGUAGE C IMMUTABLE STRICT;
1023
1023
 
1024
1024
-- Create the operator class
1025
1025
CREATE OPERATOR CLASS gist_numeric_ops
1049
1049
CREATE OR REPLACE FUNCTION gbt_bit_consistent(internal,bit,int2,oid,internal)
1050
1050
RETURNS bool
1051
1051
AS 'MODULE_PATHNAME'
1052
 
LANGUAGE C IMMUTABLE;
 
1052
LANGUAGE C IMMUTABLE STRICT;
1053
1053
 
1054
1054
CREATE OR REPLACE FUNCTION gbt_bit_compress(internal)
1055
1055
RETURNS internal
1056
1056
AS 'MODULE_PATHNAME'
1057
 
LANGUAGE C IMMUTABLE;
 
1057
LANGUAGE C IMMUTABLE STRICT;
1058
1058
 
1059
1059
CREATE OR REPLACE FUNCTION gbt_bit_penalty(internal,internal,internal)
1060
1060
RETURNS internal
1064
1064
CREATE OR REPLACE FUNCTION gbt_bit_picksplit(internal, internal)
1065
1065
RETURNS internal
1066
1066
AS 'MODULE_PATHNAME'
1067
 
LANGUAGE C IMMUTABLE;
 
1067
LANGUAGE C IMMUTABLE STRICT;
1068
1068
 
1069
1069
CREATE OR REPLACE FUNCTION gbt_bit_union(bytea, internal)
1070
1070
RETURNS gbtreekey_var
1071
1071
AS 'MODULE_PATHNAME'
1072
 
LANGUAGE C IMMUTABLE;
 
1072
LANGUAGE C IMMUTABLE STRICT;
1073
1073
 
1074
1074
CREATE OR REPLACE FUNCTION gbt_bit_same(internal, internal, internal)
1075
1075
RETURNS internal
1076
1076
AS 'MODULE_PATHNAME'
1077
 
LANGUAGE C IMMUTABLE;
 
1077
LANGUAGE C IMMUTABLE STRICT;
1078
1078
 
1079
1079
-- Create the operator class
1080
1080
CREATE OPERATOR CLASS gist_bit_ops
1126
1126
CREATE OR REPLACE FUNCTION gbt_inet_consistent(internal,inet,int2,oid,internal)
1127
1127
RETURNS bool
1128
1128
AS 'MODULE_PATHNAME'
1129
 
LANGUAGE C IMMUTABLE;
 
1129
LANGUAGE C IMMUTABLE STRICT;
1130
1130
 
1131
1131
CREATE OR REPLACE FUNCTION gbt_inet_compress(internal)
1132
1132
RETURNS internal
1133
1133
AS 'MODULE_PATHNAME'
1134
 
LANGUAGE C IMMUTABLE;
 
1134
LANGUAGE C IMMUTABLE STRICT;
1135
1135
 
1136
1136
CREATE OR REPLACE FUNCTION gbt_inet_penalty(internal,internal,internal)
1137
1137
RETURNS internal
1141
1141
CREATE OR REPLACE FUNCTION gbt_inet_picksplit(internal, internal)
1142
1142
RETURNS internal
1143
1143
AS 'MODULE_PATHNAME'
1144
 
LANGUAGE C IMMUTABLE;
 
1144
LANGUAGE C IMMUTABLE STRICT;
1145
1145
 
1146
1146
CREATE OR REPLACE FUNCTION gbt_inet_union(bytea, internal)
1147
1147
RETURNS gbtreekey16
1148
1148
AS 'MODULE_PATHNAME'
1149
 
LANGUAGE C IMMUTABLE;
 
1149
LANGUAGE C IMMUTABLE STRICT;
1150
1150
 
1151
1151
CREATE OR REPLACE FUNCTION gbt_inet_same(internal, internal, internal)
1152
1152
RETURNS internal
1153
1153
AS 'MODULE_PATHNAME'
1154
 
LANGUAGE C IMMUTABLE;
 
1154
LANGUAGE C IMMUTABLE STRICT;
1155
1155
 
1156
1156
-- Create the operator class
1157
1157
CREATE OPERATOR CLASS gist_inet_ops