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 6CREATE FUNCTION gbtreekey4_in(cstring) 7RETURNS gbtreekey4 8AS 'MODULE_PATHNAME', 'gbtreekey_in' 9LANGUAGE C IMMUTABLE STRICT; 10 11CREATE FUNCTION gbtreekey4_out(gbtreekey4) 12RETURNS cstring 13AS 'MODULE_PATHNAME', 'gbtreekey_out' 14LANGUAGE C IMMUTABLE STRICT; 15 16CREATE TYPE gbtreekey4 ( 17 INTERNALLENGTH = 4, 18 INPUT = gbtreekey4_in, 19 OUTPUT = gbtreekey4_out 20); 21 22CREATE FUNCTION gbtreekey8_in(cstring) 23RETURNS gbtreekey8 24AS 'MODULE_PATHNAME', 'gbtreekey_in' 25LANGUAGE C IMMUTABLE STRICT; 26 27CREATE FUNCTION gbtreekey8_out(gbtreekey8) 28RETURNS cstring 29AS 'MODULE_PATHNAME', 'gbtreekey_out' 30LANGUAGE C IMMUTABLE STRICT; 31 32CREATE TYPE gbtreekey8 ( 33 INTERNALLENGTH = 8, 34 INPUT = gbtreekey8_in, 35 OUTPUT = gbtreekey8_out 36); 37 38CREATE FUNCTION gbtreekey16_in(cstring) 39RETURNS gbtreekey16 40AS 'MODULE_PATHNAME', 'gbtreekey_in' 41LANGUAGE C IMMUTABLE STRICT; 42 43CREATE FUNCTION gbtreekey16_out(gbtreekey16) 44RETURNS cstring 45AS 'MODULE_PATHNAME', 'gbtreekey_out' 46LANGUAGE C IMMUTABLE STRICT; 47 48CREATE TYPE gbtreekey16 ( 49 INTERNALLENGTH = 16, 50 INPUT = gbtreekey16_in, 51 OUTPUT = gbtreekey16_out 52); 53 54CREATE FUNCTION gbtreekey32_in(cstring) 55RETURNS gbtreekey32 56AS 'MODULE_PATHNAME', 'gbtreekey_in' 57LANGUAGE C IMMUTABLE STRICT; 58 59CREATE FUNCTION gbtreekey32_out(gbtreekey32) 60RETURNS cstring 61AS 'MODULE_PATHNAME', 'gbtreekey_out' 62LANGUAGE C IMMUTABLE STRICT; 63 64CREATE TYPE gbtreekey32 ( 65 INTERNALLENGTH = 32, 66 INPUT = gbtreekey32_in, 67 OUTPUT = gbtreekey32_out 68); 69 70CREATE FUNCTION gbtreekey_var_in(cstring) 71RETURNS gbtreekey_var 72AS 'MODULE_PATHNAME', 'gbtreekey_in' 73LANGUAGE C IMMUTABLE STRICT; 74 75CREATE FUNCTION gbtreekey_var_out(gbtreekey_var) 76RETURNS cstring 77AS 'MODULE_PATHNAME', 'gbtreekey_out' 78LANGUAGE C IMMUTABLE STRICT; 79 80CREATE 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 89CREATE FUNCTION cash_dist(money, money) 90RETURNS money 91AS 'MODULE_PATHNAME' 92LANGUAGE C IMMUTABLE STRICT; 93 94CREATE OPERATOR <-> ( 95 LEFTARG = money, 96 RIGHTARG = money, 97 PROCEDURE = cash_dist, 98 COMMUTATOR = '<->' 99); 100 101CREATE FUNCTION date_dist(date, date) 102RETURNS int4 103AS 'MODULE_PATHNAME' 104LANGUAGE C IMMUTABLE STRICT; 105 106CREATE OPERATOR <-> ( 107 LEFTARG = date, 108 RIGHTARG = date, 109 PROCEDURE = date_dist, 110 COMMUTATOR = '<->' 111); 112 113CREATE FUNCTION float4_dist(float4, float4) 114RETURNS float4 115AS 'MODULE_PATHNAME' 116LANGUAGE C IMMUTABLE STRICT; 117 118CREATE OPERATOR <-> ( 119 LEFTARG = float4, 120 RIGHTARG = float4, 121 PROCEDURE = float4_dist, 122 COMMUTATOR = '<->' 123); 124 125CREATE FUNCTION float8_dist(float8, float8) 126RETURNS float8 127AS 'MODULE_PATHNAME' 128LANGUAGE C IMMUTABLE STRICT; 129 130CREATE OPERATOR <-> ( 131 LEFTARG = float8, 132 RIGHTARG = float8, 133 PROCEDURE = float8_dist, 134 COMMUTATOR = '<->' 135); 136 137CREATE FUNCTION int2_dist(int2, int2) 138RETURNS int2 139AS 'MODULE_PATHNAME' 140LANGUAGE C IMMUTABLE STRICT; 141 142CREATE OPERATOR <-> ( 143 LEFTARG = int2, 144 RIGHTARG = int2, 145 PROCEDURE = int2_dist, 146 COMMUTATOR = '<->' 147); 148 149CREATE FUNCTION int4_dist(int4, int4) 150RETURNS int4 151AS 'MODULE_PATHNAME' 152LANGUAGE C IMMUTABLE STRICT; 153 154CREATE OPERATOR <-> ( 155 LEFTARG = int4, 156 RIGHTARG = int4, 157 PROCEDURE = int4_dist, 158 COMMUTATOR = '<->' 159); 160 161CREATE FUNCTION int8_dist(int8, int8) 162RETURNS int8 163AS 'MODULE_PATHNAME' 164LANGUAGE C IMMUTABLE STRICT; 165 166CREATE OPERATOR <-> ( 167 LEFTARG = int8, 168 RIGHTARG = int8, 169 PROCEDURE = int8_dist, 170 COMMUTATOR = '<->' 171); 172 173CREATE FUNCTION interval_dist(interval, interval) 174RETURNS interval 175AS 'MODULE_PATHNAME' 176LANGUAGE C IMMUTABLE STRICT; 177 178CREATE OPERATOR <-> ( 179 LEFTARG = interval, 180 RIGHTARG = interval, 181 PROCEDURE = interval_dist, 182 COMMUTATOR = '<->' 183); 184 185CREATE FUNCTION oid_dist(oid, oid) 186RETURNS oid 187AS 'MODULE_PATHNAME' 188LANGUAGE C IMMUTABLE STRICT; 189 190CREATE OPERATOR <-> ( 191 LEFTARG = oid, 192 RIGHTARG = oid, 193 PROCEDURE = oid_dist, 194 COMMUTATOR = '<->' 195); 196 197CREATE FUNCTION time_dist(time, time) 198RETURNS interval 199AS 'MODULE_PATHNAME' 200LANGUAGE C IMMUTABLE STRICT; 201 202CREATE OPERATOR <-> ( 203 LEFTARG = time, 204 RIGHTARG = time, 205 PROCEDURE = time_dist, 206 COMMUTATOR = '<->' 207); 208 209CREATE FUNCTION ts_dist(timestamp, timestamp) 210RETURNS interval 211AS 'MODULE_PATHNAME' 212LANGUAGE C IMMUTABLE STRICT; 213 214CREATE OPERATOR <-> ( 215 LEFTARG = timestamp, 216 RIGHTARG = timestamp, 217 PROCEDURE = ts_dist, 218 COMMUTATOR = '<->' 219); 220 221CREATE FUNCTION tstz_dist(timestamptz, timestamptz) 222RETURNS interval 223AS 'MODULE_PATHNAME' 224LANGUAGE C IMMUTABLE STRICT; 225 226CREATE 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 242CREATE FUNCTION gbt_oid_consistent(internal,oid,int2,oid,internal) 243RETURNS bool 244AS 'MODULE_PATHNAME' 245LANGUAGE C IMMUTABLE STRICT; 246 247CREATE FUNCTION gbt_oid_distance(internal,oid,int2,oid,internal) 248RETURNS float8 249AS 'MODULE_PATHNAME' 250LANGUAGE C IMMUTABLE STRICT; 251 252CREATE FUNCTION gbt_oid_fetch(internal) 253RETURNS internal 254AS 'MODULE_PATHNAME' 255LANGUAGE C IMMUTABLE STRICT; 256 257CREATE FUNCTION gbt_oid_compress(internal) 258RETURNS internal 259AS 'MODULE_PATHNAME' 260LANGUAGE C IMMUTABLE STRICT; 261 262CREATE FUNCTION gbt_decompress(internal) 263RETURNS internal 264AS 'MODULE_PATHNAME' 265LANGUAGE C IMMUTABLE STRICT; 266 267CREATE FUNCTION gbt_var_decompress(internal) 268RETURNS internal 269AS 'MODULE_PATHNAME' 270LANGUAGE C IMMUTABLE STRICT; 271 272CREATE FUNCTION gbt_var_fetch(internal) 273RETURNS internal 274AS 'MODULE_PATHNAME' 275LANGUAGE C IMMUTABLE STRICT; 276 277CREATE FUNCTION gbt_oid_penalty(internal,internal,internal) 278RETURNS internal 279AS 'MODULE_PATHNAME' 280LANGUAGE C IMMUTABLE STRICT; 281 282CREATE FUNCTION gbt_oid_picksplit(internal, internal) 283RETURNS internal 284AS 'MODULE_PATHNAME' 285LANGUAGE C IMMUTABLE STRICT; 286 287CREATE FUNCTION gbt_oid_union(internal, internal) 288RETURNS gbtreekey8 289AS 'MODULE_PATHNAME' 290LANGUAGE C IMMUTABLE STRICT; 291 292CREATE FUNCTION gbt_oid_same(gbtreekey8, gbtreekey8, internal) 293RETURNS internal 294AS 'MODULE_PATHNAME' 295LANGUAGE C IMMUTABLE STRICT; 296 297-- Create the operator class 298CREATE OPERATOR CLASS gist_oid_ops 299DEFAULT FOR TYPE oid USING gist 300AS 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. 318ALTER 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 334CREATE FUNCTION gbt_int2_consistent(internal,int2,int2,oid,internal) 335RETURNS bool 336AS 'MODULE_PATHNAME' 337LANGUAGE C IMMUTABLE STRICT; 338 339CREATE FUNCTION gbt_int2_distance(internal,int2,int2,oid,internal) 340RETURNS float8 341AS 'MODULE_PATHNAME' 342LANGUAGE C IMMUTABLE STRICT; 343 344CREATE FUNCTION gbt_int2_compress(internal) 345RETURNS internal 346AS 'MODULE_PATHNAME' 347LANGUAGE C IMMUTABLE STRICT; 348 349CREATE FUNCTION gbt_int2_fetch(internal) 350RETURNS internal 351AS 'MODULE_PATHNAME' 352LANGUAGE C IMMUTABLE STRICT; 353 354CREATE FUNCTION gbt_int2_penalty(internal,internal,internal) 355RETURNS internal 356AS 'MODULE_PATHNAME' 357LANGUAGE C IMMUTABLE STRICT; 358 359CREATE FUNCTION gbt_int2_picksplit(internal, internal) 360RETURNS internal 361AS 'MODULE_PATHNAME' 362LANGUAGE C IMMUTABLE STRICT; 363 364CREATE FUNCTION gbt_int2_union(internal, internal) 365RETURNS gbtreekey4 366AS 'MODULE_PATHNAME' 367LANGUAGE C IMMUTABLE STRICT; 368 369CREATE FUNCTION gbt_int2_same(gbtreekey4, gbtreekey4, internal) 370RETURNS internal 371AS 'MODULE_PATHNAME' 372LANGUAGE C IMMUTABLE STRICT; 373 374-- Create the operator class 375CREATE OPERATOR CLASS gist_int2_ops 376DEFAULT FOR TYPE int2 USING gist 377AS 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 392ALTER 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 406CREATE FUNCTION gbt_int4_consistent(internal,int4,int2,oid,internal) 407RETURNS bool 408AS 'MODULE_PATHNAME' 409LANGUAGE C IMMUTABLE STRICT; 410 411CREATE FUNCTION gbt_int4_distance(internal,int4,int2,oid,internal) 412RETURNS float8 413AS 'MODULE_PATHNAME' 414LANGUAGE C IMMUTABLE STRICT; 415 416CREATE FUNCTION gbt_int4_compress(internal) 417RETURNS internal 418AS 'MODULE_PATHNAME' 419LANGUAGE C IMMUTABLE STRICT; 420 421CREATE FUNCTION gbt_int4_fetch(internal) 422RETURNS internal 423AS 'MODULE_PATHNAME' 424LANGUAGE C IMMUTABLE STRICT; 425 426CREATE FUNCTION gbt_int4_penalty(internal,internal,internal) 427RETURNS internal 428AS 'MODULE_PATHNAME' 429LANGUAGE C IMMUTABLE STRICT; 430 431CREATE FUNCTION gbt_int4_picksplit(internal, internal) 432RETURNS internal 433AS 'MODULE_PATHNAME' 434LANGUAGE C IMMUTABLE STRICT; 435 436CREATE FUNCTION gbt_int4_union(internal, internal) 437RETURNS gbtreekey8 438AS 'MODULE_PATHNAME' 439LANGUAGE C IMMUTABLE STRICT; 440 441CREATE FUNCTION gbt_int4_same(gbtreekey8, gbtreekey8, internal) 442RETURNS internal 443AS 'MODULE_PATHNAME' 444LANGUAGE C IMMUTABLE STRICT; 445 446-- Create the operator class 447CREATE OPERATOR CLASS gist_int4_ops 448DEFAULT FOR TYPE int4 USING gist 449AS 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 464ALTER 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 479CREATE FUNCTION gbt_int8_consistent(internal,int8,int2,oid,internal) 480RETURNS bool 481AS 'MODULE_PATHNAME' 482LANGUAGE C IMMUTABLE STRICT; 483 484CREATE FUNCTION gbt_int8_distance(internal,int8,int2,oid,internal) 485RETURNS float8 486AS 'MODULE_PATHNAME' 487LANGUAGE C IMMUTABLE STRICT; 488 489CREATE FUNCTION gbt_int8_compress(internal) 490RETURNS internal 491AS 'MODULE_PATHNAME' 492LANGUAGE C IMMUTABLE STRICT; 493 494CREATE FUNCTION gbt_int8_fetch(internal) 495RETURNS internal 496AS 'MODULE_PATHNAME' 497LANGUAGE C IMMUTABLE STRICT; 498 499CREATE FUNCTION gbt_int8_penalty(internal,internal,internal) 500RETURNS internal 501AS 'MODULE_PATHNAME' 502LANGUAGE C IMMUTABLE STRICT; 503 504CREATE FUNCTION gbt_int8_picksplit(internal, internal) 505RETURNS internal 506AS 'MODULE_PATHNAME' 507LANGUAGE C IMMUTABLE STRICT; 508 509CREATE FUNCTION gbt_int8_union(internal, internal) 510RETURNS gbtreekey16 511AS 'MODULE_PATHNAME' 512LANGUAGE C IMMUTABLE STRICT; 513 514CREATE FUNCTION gbt_int8_same(gbtreekey16, gbtreekey16, internal) 515RETURNS internal 516AS 'MODULE_PATHNAME' 517LANGUAGE C IMMUTABLE STRICT; 518 519-- Create the operator class 520CREATE OPERATOR CLASS gist_int8_ops 521DEFAULT FOR TYPE int8 USING gist 522AS 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 537ALTER 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 551CREATE FUNCTION gbt_float4_consistent(internal,float4,int2,oid,internal) 552RETURNS bool 553AS 'MODULE_PATHNAME' 554LANGUAGE C IMMUTABLE STRICT; 555 556CREATE FUNCTION gbt_float4_distance(internal,float4,int2,oid,internal) 557RETURNS float8 558AS 'MODULE_PATHNAME' 559LANGUAGE C IMMUTABLE STRICT; 560 561CREATE FUNCTION gbt_float4_compress(internal) 562RETURNS internal 563AS 'MODULE_PATHNAME' 564LANGUAGE C IMMUTABLE STRICT; 565 566CREATE FUNCTION gbt_float4_fetch(internal) 567RETURNS internal 568AS 'MODULE_PATHNAME' 569LANGUAGE C IMMUTABLE STRICT; 570 571CREATE FUNCTION gbt_float4_penalty(internal,internal,internal) 572RETURNS internal 573AS 'MODULE_PATHNAME' 574LANGUAGE C IMMUTABLE STRICT; 575 576CREATE FUNCTION gbt_float4_picksplit(internal, internal) 577RETURNS internal 578AS 'MODULE_PATHNAME' 579LANGUAGE C IMMUTABLE STRICT; 580 581CREATE FUNCTION gbt_float4_union(internal, internal) 582RETURNS gbtreekey8 583AS 'MODULE_PATHNAME' 584LANGUAGE C IMMUTABLE STRICT; 585 586CREATE FUNCTION gbt_float4_same(gbtreekey8, gbtreekey8, internal) 587RETURNS internal 588AS 'MODULE_PATHNAME' 589LANGUAGE C IMMUTABLE STRICT; 590 591-- Create the operator class 592CREATE OPERATOR CLASS gist_float4_ops 593DEFAULT FOR TYPE float4 USING gist 594AS 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 609ALTER 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 623CREATE FUNCTION gbt_float8_consistent(internal,float8,int2,oid,internal) 624RETURNS bool 625AS 'MODULE_PATHNAME' 626LANGUAGE C IMMUTABLE STRICT; 627 628CREATE FUNCTION gbt_float8_distance(internal,float8,int2,oid,internal) 629RETURNS float8 630AS 'MODULE_PATHNAME' 631LANGUAGE C IMMUTABLE STRICT; 632 633CREATE FUNCTION gbt_float8_compress(internal) 634RETURNS internal 635AS 'MODULE_PATHNAME' 636LANGUAGE C IMMUTABLE STRICT; 637 638CREATE FUNCTION gbt_float8_fetch(internal) 639RETURNS internal 640AS 'MODULE_PATHNAME' 641LANGUAGE C IMMUTABLE STRICT; 642 643CREATE FUNCTION gbt_float8_penalty(internal,internal,internal) 644RETURNS internal 645AS 'MODULE_PATHNAME' 646LANGUAGE C IMMUTABLE STRICT; 647 648CREATE FUNCTION gbt_float8_picksplit(internal, internal) 649RETURNS internal 650AS 'MODULE_PATHNAME' 651LANGUAGE C IMMUTABLE STRICT; 652 653CREATE FUNCTION gbt_float8_union(internal, internal) 654RETURNS gbtreekey16 655AS 'MODULE_PATHNAME' 656LANGUAGE C IMMUTABLE STRICT; 657 658CREATE FUNCTION gbt_float8_same(gbtreekey16, gbtreekey16, internal) 659RETURNS internal 660AS 'MODULE_PATHNAME' 661LANGUAGE C IMMUTABLE STRICT; 662 663-- Create the operator class 664CREATE OPERATOR CLASS gist_float8_ops 665DEFAULT FOR TYPE float8 USING gist 666AS 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 681ALTER 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 695CREATE FUNCTION gbt_ts_consistent(internal,timestamp,int2,oid,internal) 696RETURNS bool 697AS 'MODULE_PATHNAME' 698LANGUAGE C IMMUTABLE STRICT; 699 700CREATE FUNCTION gbt_ts_distance(internal,timestamp,int2,oid,internal) 701RETURNS float8 702AS 'MODULE_PATHNAME' 703LANGUAGE C IMMUTABLE STRICT; 704 705CREATE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2,oid,internal) 706RETURNS bool 707AS 'MODULE_PATHNAME' 708LANGUAGE C IMMUTABLE STRICT; 709 710CREATE FUNCTION gbt_tstz_distance(internal,timestamptz,int2,oid,internal) 711RETURNS float8 712AS 'MODULE_PATHNAME' 713LANGUAGE C IMMUTABLE STRICT; 714 715CREATE FUNCTION gbt_ts_compress(internal) 716RETURNS internal 717AS 'MODULE_PATHNAME' 718LANGUAGE C IMMUTABLE STRICT; 719 720CREATE FUNCTION gbt_tstz_compress(internal) 721RETURNS internal 722AS 'MODULE_PATHNAME' 723LANGUAGE C IMMUTABLE STRICT; 724 725CREATE FUNCTION gbt_ts_fetch(internal) 726RETURNS internal 727AS 'MODULE_PATHNAME' 728LANGUAGE C IMMUTABLE STRICT; 729 730CREATE FUNCTION gbt_ts_penalty(internal,internal,internal) 731RETURNS internal 732AS 'MODULE_PATHNAME' 733LANGUAGE C IMMUTABLE STRICT; 734 735CREATE FUNCTION gbt_ts_picksplit(internal, internal) 736RETURNS internal 737AS 'MODULE_PATHNAME' 738LANGUAGE C IMMUTABLE STRICT; 739 740CREATE FUNCTION gbt_ts_union(internal, internal) 741RETURNS gbtreekey16 742AS 'MODULE_PATHNAME' 743LANGUAGE C IMMUTABLE STRICT; 744 745CREATE FUNCTION gbt_ts_same(gbtreekey16, gbtreekey16, internal) 746RETURNS internal 747AS 'MODULE_PATHNAME' 748LANGUAGE C IMMUTABLE STRICT; 749 750-- Create the operator class 751CREATE OPERATOR CLASS gist_timestamp_ops 752DEFAULT FOR TYPE timestamp USING gist 753AS 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 768ALTER 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 775CREATE OPERATOR CLASS gist_timestamptz_ops 776DEFAULT FOR TYPE timestamptz USING gist 777AS 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 792ALTER 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 806CREATE FUNCTION gbt_time_consistent(internal,time,int2,oid,internal) 807RETURNS bool 808AS 'MODULE_PATHNAME' 809LANGUAGE C IMMUTABLE STRICT; 810 811CREATE FUNCTION gbt_time_distance(internal,time,int2,oid,internal) 812RETURNS float8 813AS 'MODULE_PATHNAME' 814LANGUAGE C IMMUTABLE STRICT; 815 816CREATE FUNCTION gbt_timetz_consistent(internal,timetz,int2,oid,internal) 817RETURNS bool 818AS 'MODULE_PATHNAME' 819LANGUAGE C IMMUTABLE STRICT; 820 821CREATE FUNCTION gbt_time_compress(internal) 822RETURNS internal 823AS 'MODULE_PATHNAME' 824LANGUAGE C IMMUTABLE STRICT; 825 826CREATE FUNCTION gbt_timetz_compress(internal) 827RETURNS internal 828AS 'MODULE_PATHNAME' 829LANGUAGE C IMMUTABLE STRICT; 830 831CREATE FUNCTION gbt_time_fetch(internal) 832RETURNS internal 833AS 'MODULE_PATHNAME' 834LANGUAGE C IMMUTABLE STRICT; 835 836CREATE FUNCTION gbt_time_penalty(internal,internal,internal) 837RETURNS internal 838AS 'MODULE_PATHNAME' 839LANGUAGE C IMMUTABLE STRICT; 840 841CREATE FUNCTION gbt_time_picksplit(internal, internal) 842RETURNS internal 843AS 'MODULE_PATHNAME' 844LANGUAGE C IMMUTABLE STRICT; 845 846CREATE FUNCTION gbt_time_union(internal, internal) 847RETURNS gbtreekey16 848AS 'MODULE_PATHNAME' 849LANGUAGE C IMMUTABLE STRICT; 850 851CREATE FUNCTION gbt_time_same(gbtreekey16, gbtreekey16, internal) 852RETURNS internal 853AS 'MODULE_PATHNAME' 854LANGUAGE C IMMUTABLE STRICT; 855 856-- Create the operator class 857CREATE OPERATOR CLASS gist_time_ops 858DEFAULT FOR TYPE time USING gist 859AS 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 874ALTER 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 881CREATE OPERATOR CLASS gist_timetz_ops 882DEFAULT FOR TYPE timetz USING gist 883AS 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 898ALTER 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 911CREATE FUNCTION gbt_date_consistent(internal,date,int2,oid,internal) 912RETURNS bool 913AS 'MODULE_PATHNAME' 914LANGUAGE C IMMUTABLE STRICT; 915 916CREATE FUNCTION gbt_date_distance(internal,date,int2,oid,internal) 917RETURNS float8 918AS 'MODULE_PATHNAME' 919LANGUAGE C IMMUTABLE STRICT; 920 921CREATE FUNCTION gbt_date_compress(internal) 922RETURNS internal 923AS 'MODULE_PATHNAME' 924LANGUAGE C IMMUTABLE STRICT; 925 926CREATE FUNCTION gbt_date_fetch(internal) 927RETURNS internal 928AS 'MODULE_PATHNAME' 929LANGUAGE C IMMUTABLE STRICT; 930 931CREATE FUNCTION gbt_date_penalty(internal,internal,internal) 932RETURNS internal 933AS 'MODULE_PATHNAME' 934LANGUAGE C IMMUTABLE STRICT; 935 936CREATE FUNCTION gbt_date_picksplit(internal, internal) 937RETURNS internal 938AS 'MODULE_PATHNAME' 939LANGUAGE C IMMUTABLE STRICT; 940 941CREATE FUNCTION gbt_date_union(internal, internal) 942RETURNS gbtreekey8 943AS 'MODULE_PATHNAME' 944LANGUAGE C IMMUTABLE STRICT; 945 946CREATE FUNCTION gbt_date_same(gbtreekey8, gbtreekey8, internal) 947RETURNS internal 948AS 'MODULE_PATHNAME' 949LANGUAGE C IMMUTABLE STRICT; 950 951-- Create the operator class 952CREATE OPERATOR CLASS gist_date_ops 953DEFAULT FOR TYPE date USING gist 954AS 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 969ALTER 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 984CREATE FUNCTION gbt_intv_consistent(internal,interval,int2,oid,internal) 985RETURNS bool 986AS 'MODULE_PATHNAME' 987LANGUAGE C IMMUTABLE STRICT; 988 989CREATE FUNCTION gbt_intv_distance(internal,interval,int2,oid,internal) 990RETURNS float8 991AS 'MODULE_PATHNAME' 992LANGUAGE C IMMUTABLE STRICT; 993 994CREATE FUNCTION gbt_intv_compress(internal) 995RETURNS internal 996AS 'MODULE_PATHNAME' 997LANGUAGE C IMMUTABLE STRICT; 998 999CREATE FUNCTION gbt_intv_decompress(internal) 1000RETURNS internal 1001AS 'MODULE_PATHNAME' 1002LANGUAGE C IMMUTABLE STRICT; 1003 1004CREATE FUNCTION gbt_intv_fetch(internal) 1005RETURNS internal 1006AS 'MODULE_PATHNAME' 1007LANGUAGE C IMMUTABLE STRICT; 1008 1009CREATE FUNCTION gbt_intv_penalty(internal,internal,internal) 1010RETURNS internal 1011AS 'MODULE_PATHNAME' 1012LANGUAGE C IMMUTABLE STRICT; 1013 1014CREATE FUNCTION gbt_intv_picksplit(internal, internal) 1015RETURNS internal 1016AS 'MODULE_PATHNAME' 1017LANGUAGE C IMMUTABLE STRICT; 1018 1019CREATE FUNCTION gbt_intv_union(internal, internal) 1020RETURNS gbtreekey32 1021AS 'MODULE_PATHNAME' 1022LANGUAGE C IMMUTABLE STRICT; 1023 1024CREATE FUNCTION gbt_intv_same(gbtreekey32, gbtreekey32, internal) 1025RETURNS internal 1026AS 'MODULE_PATHNAME' 1027LANGUAGE C IMMUTABLE STRICT; 1028 1029-- Create the operator class 1030CREATE OPERATOR CLASS gist_interval_ops 1031DEFAULT FOR TYPE interval USING gist 1032AS 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 1047ALTER 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 1062CREATE FUNCTION gbt_cash_consistent(internal,money,int2,oid,internal) 1063RETURNS bool 1064AS 'MODULE_PATHNAME' 1065LANGUAGE C IMMUTABLE STRICT; 1066 1067CREATE FUNCTION gbt_cash_distance(internal,money,int2,oid,internal) 1068RETURNS float8 1069AS 'MODULE_PATHNAME' 1070LANGUAGE C IMMUTABLE STRICT; 1071 1072CREATE FUNCTION gbt_cash_compress(internal) 1073RETURNS internal 1074AS 'MODULE_PATHNAME' 1075LANGUAGE C IMMUTABLE STRICT; 1076 1077CREATE FUNCTION gbt_cash_fetch(internal) 1078RETURNS internal 1079AS 'MODULE_PATHNAME' 1080LANGUAGE C IMMUTABLE STRICT; 1081 1082CREATE FUNCTION gbt_cash_penalty(internal,internal,internal) 1083RETURNS internal 1084AS 'MODULE_PATHNAME' 1085LANGUAGE C IMMUTABLE STRICT; 1086 1087CREATE FUNCTION gbt_cash_picksplit(internal, internal) 1088RETURNS internal 1089AS 'MODULE_PATHNAME' 1090LANGUAGE C IMMUTABLE STRICT; 1091 1092CREATE FUNCTION gbt_cash_union(internal, internal) 1093RETURNS gbtreekey16 1094AS 'MODULE_PATHNAME' 1095LANGUAGE C IMMUTABLE STRICT; 1096 1097CREATE FUNCTION gbt_cash_same(gbtreekey16, gbtreekey16, internal) 1098RETURNS internal 1099AS 'MODULE_PATHNAME' 1100LANGUAGE C IMMUTABLE STRICT; 1101 1102-- Create the operator class 1103CREATE OPERATOR CLASS gist_cash_ops 1104DEFAULT FOR TYPE money USING gist 1105AS 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 1120ALTER 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 1135CREATE FUNCTION gbt_macad_consistent(internal,macaddr,int2,oid,internal) 1136RETURNS bool 1137AS 'MODULE_PATHNAME' 1138LANGUAGE C IMMUTABLE STRICT; 1139 1140CREATE FUNCTION gbt_macad_compress(internal) 1141RETURNS internal 1142AS 'MODULE_PATHNAME' 1143LANGUAGE C IMMUTABLE STRICT; 1144 1145CREATE FUNCTION gbt_macad_fetch(internal) 1146RETURNS internal 1147AS 'MODULE_PATHNAME' 1148LANGUAGE C IMMUTABLE STRICT; 1149 1150CREATE FUNCTION gbt_macad_penalty(internal,internal,internal) 1151RETURNS internal 1152AS 'MODULE_PATHNAME' 1153LANGUAGE C IMMUTABLE STRICT; 1154 1155CREATE FUNCTION gbt_macad_picksplit(internal, internal) 1156RETURNS internal 1157AS 'MODULE_PATHNAME' 1158LANGUAGE C IMMUTABLE STRICT; 1159 1160CREATE FUNCTION gbt_macad_union(internal, internal) 1161RETURNS gbtreekey16 1162AS 'MODULE_PATHNAME' 1163LANGUAGE C IMMUTABLE STRICT; 1164 1165CREATE FUNCTION gbt_macad_same(gbtreekey16, gbtreekey16, internal) 1166RETURNS internal 1167AS 'MODULE_PATHNAME' 1168LANGUAGE C IMMUTABLE STRICT; 1169 1170-- Create the operator class 1171CREATE OPERATOR CLASS gist_macaddr_ops 1172DEFAULT FOR TYPE macaddr USING gist 1173AS 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 1188ALTER 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 1201CREATE FUNCTION gbt_text_consistent(internal,text,int2,oid,internal) 1202RETURNS bool 1203AS 'MODULE_PATHNAME' 1204LANGUAGE C IMMUTABLE STRICT; 1205 1206CREATE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2,oid,internal) 1207RETURNS bool 1208AS 'MODULE_PATHNAME' 1209LANGUAGE C IMMUTABLE STRICT; 1210 1211CREATE FUNCTION gbt_text_compress(internal) 1212RETURNS internal 1213AS 'MODULE_PATHNAME' 1214LANGUAGE C IMMUTABLE STRICT; 1215 1216CREATE FUNCTION gbt_bpchar_compress(internal) 1217RETURNS internal 1218AS 'MODULE_PATHNAME' 1219LANGUAGE C IMMUTABLE STRICT; 1220 1221CREATE FUNCTION gbt_text_penalty(internal,internal,internal) 1222RETURNS internal 1223AS 'MODULE_PATHNAME' 1224LANGUAGE C IMMUTABLE STRICT; 1225 1226CREATE FUNCTION gbt_text_picksplit(internal, internal) 1227RETURNS internal 1228AS 'MODULE_PATHNAME' 1229LANGUAGE C IMMUTABLE STRICT; 1230 1231CREATE FUNCTION gbt_text_union(internal, internal) 1232RETURNS gbtreekey_var 1233AS 'MODULE_PATHNAME' 1234LANGUAGE C IMMUTABLE STRICT; 1235 1236CREATE FUNCTION gbt_text_same(gbtreekey_var, gbtreekey_var, internal) 1237RETURNS internal 1238AS 'MODULE_PATHNAME' 1239LANGUAGE C IMMUTABLE STRICT; 1240 1241-- Create the operator class 1242CREATE OPERATOR CLASS gist_text_ops 1243DEFAULT FOR TYPE text USING gist 1244AS 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 1259ALTER 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 1265CREATE OPERATOR CLASS gist_bpchar_ops 1266DEFAULT FOR TYPE bpchar USING gist 1267AS 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 1282ALTER 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 1293CREATE FUNCTION gbt_bytea_consistent(internal,bytea,int2,oid,internal) 1294RETURNS bool 1295AS 'MODULE_PATHNAME' 1296LANGUAGE C IMMUTABLE STRICT; 1297 1298CREATE FUNCTION gbt_bytea_compress(internal) 1299RETURNS internal 1300AS 'MODULE_PATHNAME' 1301LANGUAGE C IMMUTABLE STRICT; 1302 1303CREATE FUNCTION gbt_bytea_penalty(internal,internal,internal) 1304RETURNS internal 1305AS 'MODULE_PATHNAME' 1306LANGUAGE C IMMUTABLE STRICT; 1307 1308CREATE FUNCTION gbt_bytea_picksplit(internal, internal) 1309RETURNS internal 1310AS 'MODULE_PATHNAME' 1311LANGUAGE C IMMUTABLE STRICT; 1312 1313CREATE FUNCTION gbt_bytea_union(internal, internal) 1314RETURNS gbtreekey_var 1315AS 'MODULE_PATHNAME' 1316LANGUAGE C IMMUTABLE STRICT; 1317 1318CREATE FUNCTION gbt_bytea_same(gbtreekey_var, gbtreekey_var, internal) 1319RETURNS internal 1320AS 'MODULE_PATHNAME' 1321LANGUAGE C IMMUTABLE STRICT; 1322 1323-- Create the operator class 1324CREATE OPERATOR CLASS gist_bytea_ops 1325DEFAULT FOR TYPE bytea USING gist 1326AS 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 1341ALTER 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 1354CREATE FUNCTION gbt_numeric_consistent(internal,numeric,int2,oid,internal) 1355RETURNS bool 1356AS 'MODULE_PATHNAME' 1357LANGUAGE C IMMUTABLE STRICT; 1358 1359CREATE FUNCTION gbt_numeric_compress(internal) 1360RETURNS internal 1361AS 'MODULE_PATHNAME' 1362LANGUAGE C IMMUTABLE STRICT; 1363 1364CREATE FUNCTION gbt_numeric_penalty(internal,internal,internal) 1365RETURNS internal 1366AS 'MODULE_PATHNAME' 1367LANGUAGE C IMMUTABLE STRICT; 1368 1369CREATE FUNCTION gbt_numeric_picksplit(internal, internal) 1370RETURNS internal 1371AS 'MODULE_PATHNAME' 1372LANGUAGE C IMMUTABLE STRICT; 1373 1374CREATE FUNCTION gbt_numeric_union(internal, internal) 1375RETURNS gbtreekey_var 1376AS 'MODULE_PATHNAME' 1377LANGUAGE C IMMUTABLE STRICT; 1378 1379CREATE FUNCTION gbt_numeric_same(gbtreekey_var, gbtreekey_var, internal) 1380RETURNS internal 1381AS 'MODULE_PATHNAME' 1382LANGUAGE C IMMUTABLE STRICT; 1383 1384-- Create the operator class 1385CREATE OPERATOR CLASS gist_numeric_ops 1386DEFAULT FOR TYPE numeric USING gist 1387AS 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 1402ALTER 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 1414CREATE FUNCTION gbt_bit_consistent(internal,bit,int2,oid,internal) 1415RETURNS bool 1416AS 'MODULE_PATHNAME' 1417LANGUAGE C IMMUTABLE STRICT; 1418 1419CREATE FUNCTION gbt_bit_compress(internal) 1420RETURNS internal 1421AS 'MODULE_PATHNAME' 1422LANGUAGE C IMMUTABLE STRICT; 1423 1424CREATE FUNCTION gbt_bit_penalty(internal,internal,internal) 1425RETURNS internal 1426AS 'MODULE_PATHNAME' 1427LANGUAGE C IMMUTABLE STRICT; 1428 1429CREATE FUNCTION gbt_bit_picksplit(internal, internal) 1430RETURNS internal 1431AS 'MODULE_PATHNAME' 1432LANGUAGE C IMMUTABLE STRICT; 1433 1434CREATE FUNCTION gbt_bit_union(internal, internal) 1435RETURNS gbtreekey_var 1436AS 'MODULE_PATHNAME' 1437LANGUAGE C IMMUTABLE STRICT; 1438 1439CREATE FUNCTION gbt_bit_same(gbtreekey_var, gbtreekey_var, internal) 1440RETURNS internal 1441AS 'MODULE_PATHNAME' 1442LANGUAGE C IMMUTABLE STRICT; 1443 1444-- Create the operator class 1445CREATE OPERATOR CLASS gist_bit_ops 1446DEFAULT FOR TYPE bit USING gist 1447AS 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 1462ALTER 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 1468CREATE OPERATOR CLASS gist_vbit_ops 1469DEFAULT FOR TYPE varbit USING gist 1470AS 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 1485ALTER 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 1498CREATE FUNCTION gbt_inet_consistent(internal,inet,int2,oid,internal) 1499RETURNS bool 1500AS 'MODULE_PATHNAME' 1501LANGUAGE C IMMUTABLE STRICT; 1502 1503CREATE FUNCTION gbt_inet_compress(internal) 1504RETURNS internal 1505AS 'MODULE_PATHNAME' 1506LANGUAGE C IMMUTABLE STRICT; 1507 1508CREATE FUNCTION gbt_inet_penalty(internal,internal,internal) 1509RETURNS internal 1510AS 'MODULE_PATHNAME' 1511LANGUAGE C IMMUTABLE STRICT; 1512 1513CREATE FUNCTION gbt_inet_picksplit(internal, internal) 1514RETURNS internal 1515AS 'MODULE_PATHNAME' 1516LANGUAGE C IMMUTABLE STRICT; 1517 1518CREATE FUNCTION gbt_inet_union(internal, internal) 1519RETURNS gbtreekey16 1520AS 'MODULE_PATHNAME' 1521LANGUAGE C IMMUTABLE STRICT; 1522 1523CREATE FUNCTION gbt_inet_same(gbtreekey16, gbtreekey16, internal) 1524RETURNS internal 1525AS 'MODULE_PATHNAME' 1526LANGUAGE C IMMUTABLE STRICT; 1527 1528-- Create the operator class 1529CREATE OPERATOR CLASS gist_inet_ops 1530DEFAULT FOR TYPE inet USING gist 1531AS 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 1546ALTER 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 1551CREATE OPERATOR CLASS gist_cidr_ops 1552DEFAULT FOR TYPE cidr USING gist 1553AS 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 1568ALTER OPERATOR FAMILY gist_cidr_ops USING gist ADD 1569 OPERATOR 6 <> (inet, inet) ; 1570 -- no fetch support, the compress function is lossy 1571