contrib/btree_gist/btree_gist--1.2.sql

   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