hstore--2.0.sql

   1 /* contrib/hstore/hstore--2.0.sql */
   2
   3 -- complain if script is sourced in psql, rather than via CREATE EXTENSION
   4 \echo Use "CREATE EXTENSION hstore" to load this file. \quit
   5
   6 CREATE TYPE hstore;
   7
   8 CREATE FUNCTION hstore_in(cstring)
   9 RETURNS hstore
  10 AS 'MODULE_PATHNAME'
  11 LANGUAGE C STRICT IMMUTABLE;
  12
  13 CREATE FUNCTION hstore_out(hstore)
  14 RETURNS cstring
  15 AS 'MODULE_PATHNAME'
  16 LANGUAGE C STRICT IMMUTABLE;
  17
  18 CREATE FUNCTION hstore_recv(internal)
  19 RETURNS hstore
  20 AS 'MODULE_PATHNAME'
  21 LANGUAGE C STRICT IMMUTABLE;
  22
  23 CREATE FUNCTION hstore_send(hstore)
  24 RETURNS bytea
  25 AS 'MODULE_PATHNAME'
  26 LANGUAGE C STRICT IMMUTABLE;
  27
  28 CREATE TYPE hstore (
  29         INTERNALLENGTH = -1,
  30         INPUT = hstore_in,
  31         OUTPUT = hstore_out,
  32         RECEIVE = hstore_recv,
  33         SEND = hstore_send,
  34         STORAGE = extended
  35 );
  36
  37 CREATE FUNCTION hstore_version_diag(hstore)
  38 RETURNS integer
  39 AS 'MODULE_PATHNAME','hstore_version_diag'
  40 LANGUAGE C STRICT IMMUTABLE;
  41
  42 CREATE FUNCTION fetchval(hstore,text)
  43 RETURNS text
  44 AS 'MODULE_PATHNAME','hstore_fetchval'
  45 LANGUAGE C STRICT IMMUTABLE;
  46
  47 CREATE OPERATOR -> (
  48         LEFTARG = hstore,
  49         RIGHTARG = text,
  50         PROCEDURE = fetchval
  51 );
  52
  53 CREATE FUNCTION fetchval_numeric(hstore,text)
  54 RETURNS numeric
  55 AS 'MODULE_PATHNAME','hstore_fetchval_numeric'
  56 LANGUAGE C STRICT IMMUTABLE;
  57
  58 CREATE OPERATOR ^> (
  59         LEFTARG = hstore,
  60         RIGHTARG = text,
  61         PROCEDURE = fetchval_numeric
  62 );
  63
  64 CREATE FUNCTION fetchval_boolean(hstore,text)
  65 RETURNS boolean
  66 AS 'MODULE_PATHNAME','hstore_fetchval_boolean'
  67 LANGUAGE C STRICT IMMUTABLE;
  68
  69 CREATE OPERATOR ?> (
  70         LEFTARG = hstore,
  71         RIGHTARG = text,
  72         PROCEDURE = fetchval_boolean
  73 );
  74
  75 CREATE FUNCTION fetchval(hstore,int)
  76 RETURNS text
  77 AS 'MODULE_PATHNAME','hstore_fetchval_n'
  78 LANGUAGE C STRICT IMMUTABLE;
  79
  80 CREATE OPERATOR -> (
  81         LEFTARG = hstore,
  82         RIGHTARG = int,
  83         PROCEDURE = fetchval
  84 );
  85
  86 CREATE FUNCTION fetchval_numeric(hstore,int)
  87 RETURNS numeric
  88 AS 'MODULE_PATHNAME','hstore_fetchval_n_numeric'
  89 LANGUAGE C STRICT IMMUTABLE;
  90
  91 CREATE OPERATOR ^> (
  92         LEFTARG = hstore,
  93         RIGHTARG = int,
  94         PROCEDURE = fetchval_numeric
  95 );
  96
  97 CREATE FUNCTION fetchval_boolean(hstore,int)
  98 RETURNS boolean
  99 AS 'MODULE_PATHNAME','hstore_fetchval_n_boolean'
 100 LANGUAGE C STRICT IMMUTABLE;
 101
 102 CREATE OPERATOR ?> (
 103         LEFTARG = hstore,
 104         RIGHTARG = int,
 105         PROCEDURE = fetchval_boolean
 106 );
 107
 108 CREATE FUNCTION fetchval(hstore,text[])
 109 RETURNS text
 110 AS 'MODULE_PATHNAME','hstore_fetchval_path'
 111 LANGUAGE C STRICT IMMUTABLE;
 112
 113 CREATE OPERATOR #> (
 114         LEFTARG = hstore,
 115         RIGHTARG = text[],
 116         PROCEDURE = fetchval
 117 );
 118
 119 CREATE FUNCTION fetchval_numeric(hstore,text[])
 120 RETURNS numeric
 121 AS 'MODULE_PATHNAME','hstore_fetchval_path_numeric'
 122 LANGUAGE C STRICT IMMUTABLE;
 123
 124 CREATE OPERATOR #^> (
 125         LEFTARG = hstore,
 126         RIGHTARG = text[],
 127         PROCEDURE = fetchval_numeric
 128 );
 129
 130 CREATE FUNCTION fetchval_boolean(hstore,text[])
 131 RETURNS boolean
 132 AS 'MODULE_PATHNAME','hstore_fetchval_path_boolean'
 133 LANGUAGE C STRICT IMMUTABLE;
 134
 135 CREATE OPERATOR #?> (
 136         LEFTARG = hstore,
 137         RIGHTARG = text[],
 138         PROCEDURE = fetchval_boolean
 139 );
 140
 141 CREATE FUNCTION fetchval_hstore(hstore,text)
 142 RETURNS hstore
 143 AS 'MODULE_PATHNAME','hstore_fetchval_hstore'
 144 LANGUAGE C STRICT IMMUTABLE;
 145
 146 CREATE OPERATOR %> (
 147         LEFTARG = hstore,
 148         RIGHTARG = text,
 149         PROCEDURE = fetchval_hstore
 150 );
 151
 152 CREATE FUNCTION fetchval_hstore(hstore,int)
 153 RETURNS hstore
 154 AS 'MODULE_PATHNAME','hstore_fetchval_n_hstore'
 155 LANGUAGE C STRICT IMMUTABLE;
 156
 157 CREATE OPERATOR %> (
 158         LEFTARG = hstore,
 159         RIGHTARG = int,
 160         PROCEDURE = fetchval_hstore
 161 );
 162
 163 CREATE FUNCTION fetchval_hstore(hstore,text[])
 164 RETURNS hstore
 165 AS 'MODULE_PATHNAME','hstore_fetchval_path_hstore'
 166 LANGUAGE C STRICT IMMUTABLE;
 167
 168 CREATE OPERATOR #%> (
 169         LEFTARG = hstore,
 170         RIGHTARG = text[],
 171         PROCEDURE = fetchval_hstore
 172 );
 173
 174 CREATE FUNCTION slice_array(hstore,text[])
 175 RETURNS text[]
 176 AS 'MODULE_PATHNAME','hstore_slice_to_array'
 177 LANGUAGE C STRICT IMMUTABLE;
 178
 179 CREATE OPERATOR -> (
 180         LEFTARG = hstore,
 181         RIGHTARG = text[],
 182         PROCEDURE = slice_array
 183 );
 184
 185 CREATE FUNCTION slice(hstore,text[])
 186 RETURNS hstore
 187 AS 'MODULE_PATHNAME','hstore_slice_to_hstore'
 188 LANGUAGE C STRICT IMMUTABLE;
 189
 190 CREATE FUNCTION isexists(hstore,text)
 191 RETURNS bool
 192 AS 'MODULE_PATHNAME','hstore_exists'
 193 LANGUAGE C STRICT IMMUTABLE;
 194
 195 CREATE FUNCTION exist(hstore,text)
 196 RETURNS bool
 197 AS 'MODULE_PATHNAME','hstore_exists'
 198 LANGUAGE C STRICT IMMUTABLE;
 199
 200 CREATE OPERATOR ? (
 201         LEFTARG = hstore,
 202         RIGHTARG = text,
 203         PROCEDURE = exist,
 204         RESTRICT = contsel,
 205         JOIN = contjoinsel
 206 );
 207
 208 CREATE FUNCTION isexists(hstore,int)
 209 RETURNS bool
 210 AS 'MODULE_PATHNAME','hstore_exists_idx'
 211 LANGUAGE C STRICT IMMUTABLE;
 212
 213 CREATE FUNCTION exist(hstore,int)
 214 RETURNS bool
 215 AS 'MODULE_PATHNAME','hstore_exists_idx'
 216 LANGUAGE C STRICT IMMUTABLE;
 217
 218 CREATE OPERATOR ? (
 219         LEFTARG = hstore,
 220         RIGHTARG = int,
 221         PROCEDURE = exist,
 222         RESTRICT = contsel,
 223         JOIN = contjoinsel
 224 );
 225
 226 CREATE FUNCTION isexists(hstore,text[])
 227 RETURNS bool
 228 AS 'MODULE_PATHNAME','hstore_exists_path'
 229 LANGUAGE C STRICT IMMUTABLE;
 230
 231 CREATE FUNCTION exist(hstore,text[])
 232 RETURNS bool
 233 AS 'MODULE_PATHNAME','hstore_exists_path'
 234 LANGUAGE C STRICT IMMUTABLE;
 235
 236 CREATE OPERATOR #? (
 237         LEFTARG = hstore,
 238         RIGHTARG = text[],
 239         PROCEDURE = exist,
 240         RESTRICT = contsel,
 241         JOIN = contjoinsel
 242 );
 243
 244 CREATE FUNCTION exists_any(hstore,text[])
 245 RETURNS bool
 246 AS 'MODULE_PATHNAME','hstore_exists_any'
 247 LANGUAGE C STRICT IMMUTABLE;
 248
 249 CREATE OPERATOR ?| (
 250         LEFTARG = hstore,
 251         RIGHTARG = text[],
 252         PROCEDURE = exists_any,
 253         RESTRICT = contsel,
 254         JOIN = contjoinsel
 255 );
 256
 257 CREATE FUNCTION exists_all(hstore,text[])
 258 RETURNS bool
 259 AS 'MODULE_PATHNAME','hstore_exists_all'
 260 LANGUAGE C STRICT IMMUTABLE;
 261
 262 CREATE OPERATOR ?& (
 263         LEFTARG = hstore,
 264         RIGHTARG = text[],
 265         PROCEDURE = exists_all,
 266         RESTRICT = contsel,
 267         JOIN = contjoinsel
 268 );
 269
 270 CREATE FUNCTION isdefined(hstore,text)
 271 RETURNS bool
 272 AS 'MODULE_PATHNAME','hstore_defined'
 273 LANGUAGE C STRICT IMMUTABLE;
 274
 275 CREATE FUNCTION defined(hstore,text)
 276 RETURNS bool
 277 AS 'MODULE_PATHNAME','hstore_defined'
 278 LANGUAGE C STRICT IMMUTABLE;
 279
 280 CREATE FUNCTION delete(hstore,text)
 281 RETURNS hstore
 282 AS 'MODULE_PATHNAME','hstore_delete'
 283 LANGUAGE C STRICT IMMUTABLE;
 284
 285 CREATE FUNCTION delete(hstore,int)
 286 RETURNS hstore
 287 AS 'MODULE_PATHNAME','hstore_delete_idx'
 288 LANGUAGE C STRICT IMMUTABLE;
 289
 290 CREATE FUNCTION delete(hstore,text[])
 291 RETURNS hstore
 292 AS 'MODULE_PATHNAME','hstore_delete_array'
 293 LANGUAGE C STRICT IMMUTABLE;
 294
 295 CREATE FUNCTION delete(hstore,hstore)
 296 RETURNS hstore
 297 AS 'MODULE_PATHNAME','hstore_delete_hstore'
 298 LANGUAGE C STRICT IMMUTABLE;
 299
 300 CREATE FUNCTION delete_path(hstore,text[])
 301 RETURNS hstore
 302 AS 'MODULE_PATHNAME','hstore_delete_path'
 303 LANGUAGE C STRICT IMMUTABLE;
 304
 305 CREATE OPERATOR - (
 306         LEFTARG = hstore,
 307         RIGHTARG = text,
 308         PROCEDURE = delete
 309 );
 310
 311 CREATE OPERATOR - (
 312         LEFTARG = hstore,
 313         RIGHTARG = int,
 314         PROCEDURE = delete
 315 );
 316
 317 CREATE OPERATOR - (
 318         LEFTARG = hstore,
 319         RIGHTARG = text[],
 320         PROCEDURE = delete
 321 );
 322
 323 CREATE OPERATOR - (
 324         LEFTARG = hstore,
 325         RIGHTARG = hstore,
 326         PROCEDURE = delete
 327 );
 328
 329 CREATE OPERATOR #- (
 330         LEFTARG = hstore,
 331         RIGHTARG = text[],
 332         PROCEDURE = delete_path
 333 );
 334
 335 CREATE FUNCTION replace(hstore,text[],hstore)
 336 RETURNS hstore
 337 AS 'MODULE_PATHNAME','hstore_replace'
 338 LANGUAGE C STRICT IMMUTABLE;
 339
 340 CREATE FUNCTION hs_concat(hstore,hstore)
 341 RETURNS hstore
 342 AS 'MODULE_PATHNAME','hstore_concat'
 343 LANGUAGE C STRICT IMMUTABLE;
 344
 345 CREATE OPERATOR || (
 346         LEFTARG = hstore,
 347         RIGHTARG = hstore,
 348         PROCEDURE = hs_concat
 349 );
 350
 351 CREATE FUNCTION concat_path(hstore,text[],hstore)
 352 RETURNS hstore
 353 AS 'MODULE_PATHNAME','hstore_deep_concat'
 354 LANGUAGE C STRICT IMMUTABLE;
 355
 356 CREATE FUNCTION hs_contains(hstore,hstore)
 357 RETURNS bool
 358 AS 'MODULE_PATHNAME','hstore_contains'
 359 LANGUAGE C STRICT IMMUTABLE;
 360
 361 CREATE FUNCTION hs_contained(hstore,hstore)
 362 RETURNS bool
 363 AS 'MODULE_PATHNAME','hstore_contained'
 364 LANGUAGE C STRICT IMMUTABLE;
 365
 366 CREATE OPERATOR @> (
 367         LEFTARG = hstore,
 368         RIGHTARG = hstore,
 369         PROCEDURE = hs_contains,
 370         COMMUTATOR = '<@',
 371         RESTRICT = contsel,
 372         JOIN = contjoinsel
 373 );
 374
 375 CREATE OPERATOR <@ (
 376         LEFTARG = hstore,
 377         RIGHTARG = hstore,
 378         PROCEDURE = hs_contained,
 379         COMMUTATOR = '@>',
 380         RESTRICT = contsel,
 381         JOIN = contjoinsel
 382 );
 383
 384 -- obsolete:
 385 CREATE OPERATOR @ (
 386         LEFTARG = hstore,
 387         RIGHTARG = hstore,
 388         PROCEDURE = hs_contains,
 389         COMMUTATOR = '~',
 390         RESTRICT = contsel,
 391         JOIN = contjoinsel
 392 );
 393
 394 CREATE OPERATOR ~ (
 395         LEFTARG = hstore,
 396         RIGHTARG = hstore,
 397         PROCEDURE = hs_contained,
 398         COMMUTATOR = '@',
 399         RESTRICT = contsel,
 400         JOIN = contjoinsel
 401 );
 402
 403 CREATE FUNCTION tconvert(text,text)
 404 RETURNS hstore
 405 AS 'MODULE_PATHNAME','hstore_from_text'
 406 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 407
 408 CREATE FUNCTION hstore(text,text)
 409 RETURNS hstore
 410 AS 'MODULE_PATHNAME','hstore_from_text'
 411 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 412
 413 CREATE FUNCTION hstore(text,bool)
 414 RETURNS hstore
 415 AS 'MODULE_PATHNAME','hstore_from_bool'
 416 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 417
 418 CREATE FUNCTION hstore(text,numeric)
 419 RETURNS hstore
 420 AS 'MODULE_PATHNAME','hstore_from_numeric'
 421 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 422
 423 CREATE FUNCTION hstore(text,hstore)
 424 RETURNS hstore
 425 AS 'MODULE_PATHNAME','hstore_from_th'
 426 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 427
 428 CREATE FUNCTION hstore(text)
 429 RETURNS hstore
 430 AS 'MODULE_PATHNAME','hstore_scalar_from_text'
 431 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 432
 433 CREATE FUNCTION hstore(bool)
 434 RETURNS hstore
 435 AS 'MODULE_PATHNAME','hstore_scalar_from_bool'
 436 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 437
 438 CREATE FUNCTION hstore(numeric)
 439 RETURNS hstore
 440 AS 'MODULE_PATHNAME','hstore_scalar_from_numeric'
 441 LANGUAGE C IMMUTABLE; -- not STRICT; needs to allow (key,NULL)
 442
 443 CREATE FUNCTION hstore(text[],text[])
 444 RETURNS hstore
 445 AS 'MODULE_PATHNAME', 'hstore_from_arrays'
 446 LANGUAGE C IMMUTABLE; -- not STRICT; allows (keys,null)
 447
 448 CREATE FUNCTION hstore(text[])
 449 RETURNS hstore
 450 AS 'MODULE_PATHNAME', 'hstore_from_array'
 451 LANGUAGE C IMMUTABLE STRICT;
 452
 453 CREATE CAST (text[] AS hstore)
 454   WITH FUNCTION hstore(text[]);
 455
 456 CREATE FUNCTION hstore_to_json(hstore)
 457 RETURNS json
 458 AS 'MODULE_PATHNAME', 'hstore_to_json'
 459 LANGUAGE C IMMUTABLE STRICT;
 460
 461 CREATE CAST (hstore AS json)
 462   WITH FUNCTION hstore_to_json(hstore);
 463
 464 CREATE FUNCTION hstore_to_json_loose(hstore)
 465 RETURNS json
 466 AS 'MODULE_PATHNAME', 'hstore_to_json_loose'
 467 LANGUAGE C IMMUTABLE STRICT;
 468
 469 CREATE FUNCTION hstore(record)
 470 RETURNS hstore
 471 AS 'MODULE_PATHNAME', 'hstore_from_record'
 472 LANGUAGE C IMMUTABLE; -- not STRICT; allows (null::recordtype)
 473
 474 CREATE FUNCTION hstore_to_array(hstore)
 475 RETURNS text[]
 476 AS 'MODULE_PATHNAME','hstore_to_array'
 477 LANGUAGE C STRICT IMMUTABLE;
 478
 479 CREATE OPERATOR %% (
 480        RIGHTARG = hstore,
 481        PROCEDURE = hstore_to_array
 482 );
 483
 484 CREATE FUNCTION hstore_to_matrix(hstore)
 485 RETURNS text[]
 486 AS 'MODULE_PATHNAME','hstore_to_matrix'
 487 LANGUAGE C STRICT IMMUTABLE;
 488
 489 CREATE OPERATOR %# (
 490        RIGHTARG = hstore,
 491        PROCEDURE = hstore_to_matrix
 492 );
 493
 494 CREATE FUNCTION akeys(hstore)
 495 RETURNS text[]
 496 AS 'MODULE_PATHNAME','hstore_akeys'
 497 LANGUAGE C STRICT IMMUTABLE;
 498
 499 CREATE FUNCTION avals(hstore)
 500 RETURNS text[]
 501 AS 'MODULE_PATHNAME','hstore_avals'
 502 LANGUAGE C STRICT IMMUTABLE;
 503
 504 CREATE FUNCTION skeys(hstore)
 505 RETURNS setof text
 506 AS 'MODULE_PATHNAME','hstore_skeys'
 507 LANGUAGE C STRICT IMMUTABLE;
 508
 509 CREATE FUNCTION svals(hstore)
 510 RETURNS setof text
 511 AS 'MODULE_PATHNAME','hstore_svals'
 512 LANGUAGE C STRICT IMMUTABLE;
 513
 514 CREATE FUNCTION svals(hstore, text[])
 515 RETURNS setof text
 516 AS 'MODULE_PATHNAME','hstore_svals_path'
 517 LANGUAGE C STRICT IMMUTABLE;
 518
 519 CREATE FUNCTION hvals(hstore)
 520 RETURNS setof hstore
 521 AS 'MODULE_PATHNAME','hstore_hvals'
 522 LANGUAGE C STRICT IMMUTABLE;
 523
 524 CREATE FUNCTION hvals(hstore, text[])
 525 RETURNS setof hstore
 526 AS 'MODULE_PATHNAME','hstore_hvals_path'
 527 LANGUAGE C STRICT IMMUTABLE;
 528
 529 CREATE FUNCTION each(IN hs hstore,
 530     OUT key text,
 531     OUT value text)
 532 RETURNS SETOF record
 533 AS 'MODULE_PATHNAME','hstore_each'
 534 LANGUAGE C STRICT IMMUTABLE;
 535
 536 CREATE FUNCTION each_hstore(IN hs hstore,
 537     OUT key text,
 538     OUT value hstore)
 539 RETURNS SETOF record
 540 AS 'MODULE_PATHNAME','hstore_each_hstore'
 541 LANGUAGE C STRICT IMMUTABLE;
 542
 543 CREATE FUNCTION hstore_typeof(hstore)
 544 RETURNS text
 545 AS 'MODULE_PATHNAME','hstore_typeof'
 546 LANGUAGE C STRICT IMMUTABLE;
 547
 548 CREATE FUNCTION populate_record(anyelement,hstore)
 549 RETURNS anyelement
 550 AS 'MODULE_PATHNAME', 'hstore_populate_record'
 551 LANGUAGE C IMMUTABLE; -- not STRICT; allows (null::rectype,hstore)
 552
 553 CREATE OPERATOR #= (
 554         LEFTARG = anyelement,
 555         RIGHTARG = hstore,
 556         PROCEDURE = populate_record
 557 );
 558
 559 CREATE FUNCTION json_to_hstore(json)
 560 RETURNS hstore
 561 AS 'MODULE_PATHNAME','json_to_hstore'
 562 LANGUAGE C STRICT IMMUTABLE;
 563
 564 CREATE CAST (json AS hstore)
 565 WITH FUNCTION json_to_hstore(json);
 566
 567 CREATE FUNCTION array_to_hstore(anyarray)
 568 RETURNS hstore
 569 AS 'MODULE_PATHNAME','array_to_hstore'
 570 LANGUAGE C STRICT IMMUTABLE;
 571
 572 -- btree support
 573
 574 CREATE FUNCTION hstore_eq(hstore,hstore)
 575 RETURNS boolean
 576 AS 'MODULE_PATHNAME','hstore_eq'
 577 LANGUAGE C STRICT IMMUTABLE;
 578
 579 CREATE FUNCTION hstore_ne(hstore,hstore)
 580 RETURNS boolean
 581 AS 'MODULE_PATHNAME','hstore_ne'
 582 LANGUAGE C STRICT IMMUTABLE;
 583
 584 CREATE FUNCTION hstore_gt(hstore,hstore)
 585 RETURNS boolean
 586 AS 'MODULE_PATHNAME','hstore_gt'
 587 LANGUAGE C STRICT IMMUTABLE;
 588
 589 CREATE FUNCTION hstore_ge(hstore,hstore)
 590 RETURNS boolean
 591 AS 'MODULE_PATHNAME','hstore_ge'
 592 LANGUAGE C STRICT IMMUTABLE;
 593
 594 CREATE FUNCTION hstore_lt(hstore,hstore)
 595 RETURNS boolean
 596 AS 'MODULE_PATHNAME','hstore_lt'
 597 LANGUAGE C STRICT IMMUTABLE;
 598
 599 CREATE FUNCTION hstore_le(hstore,hstore)
 600 RETURNS boolean
 601 AS 'MODULE_PATHNAME','hstore_le'
 602 LANGUAGE C STRICT IMMUTABLE;
 603
 604 CREATE FUNCTION hstore_cmp(hstore,hstore)
 605 RETURNS integer
 606 AS 'MODULE_PATHNAME','hstore_cmp'
 607 LANGUAGE C STRICT IMMUTABLE;
 608
 609 CREATE OPERATOR = (
 610        LEFTARG = hstore,
 611        RIGHTARG = hstore,
 612        PROCEDURE = hstore_eq,
 613        COMMUTATOR = =,
 614        NEGATOR = <>,
 615        RESTRICT = eqsel,
 616        JOIN = eqjoinsel,
 617        MERGES,
 618        HASHES
 619 );
 620 CREATE OPERATOR <> (
 621        LEFTARG = hstore,
 622        RIGHTARG = hstore,
 623        PROCEDURE = hstore_ne,
 624        COMMUTATOR = <>,
 625        NEGATOR = =,
 626        RESTRICT = neqsel,
 627        JOIN = neqjoinsel
 628 );
 629
 630 -- the comparison operators have funky names (and are undocumented)
 631 -- in an attempt to discourage anyone from actually using them. they
 632 -- only exist to support the btree opclass
 633
 634 CREATE OPERATOR #<# (
 635        LEFTARG = hstore,
 636        RIGHTARG = hstore,
 637        PROCEDURE = hstore_lt,
 638        COMMUTATOR = #>#,
 639        NEGATOR = #>=#,
 640        RESTRICT = scalarltsel,
 641        JOIN = scalarltjoinsel
 642 );
 643 CREATE OPERATOR #<=# (
 644        LEFTARG = hstore,
 645        RIGHTARG = hstore,
 646        PROCEDURE = hstore_le,
 647        COMMUTATOR = #>=#,
 648        NEGATOR = #>#,
 649        RESTRICT = scalarltsel,
 650        JOIN = scalarltjoinsel
 651 );
 652 CREATE OPERATOR #># (
 653        LEFTARG = hstore,
 654        RIGHTARG = hstore,
 655        PROCEDURE = hstore_gt,
 656        COMMUTATOR = #<#,
 657        NEGATOR = #<=#,
 658        RESTRICT = scalargtsel,
 659        JOIN = scalargtjoinsel
 660 );
 661 CREATE OPERATOR #>=# (
 662        LEFTARG = hstore,
 663        RIGHTARG = hstore,
 664        PROCEDURE = hstore_ge,
 665        COMMUTATOR = #<=#,
 666        NEGATOR = #<#,
 667        RESTRICT = scalargtsel,
 668        JOIN = scalargtjoinsel
 669 );
 670
 671 CREATE OPERATOR CLASS btree_hstore_ops
 672 DEFAULT FOR TYPE hstore USING btree
 673 AS
 674         OPERATOR        1       #<# ,
 675         OPERATOR        2       #<=# ,
 676         OPERATOR        3       = ,
 677         OPERATOR        4       #>=# ,
 678         OPERATOR        5       #># ,
 679         FUNCTION        1       hstore_cmp(hstore,hstore);
 680
 681 -- hash support
 682
 683 CREATE FUNCTION hstore_hash(hstore)
 684 RETURNS integer
 685 AS 'MODULE_PATHNAME','hstore_hash'
 686 LANGUAGE C STRICT IMMUTABLE;
 687
 688 CREATE OPERATOR CLASS hash_hstore_ops
 689 DEFAULT FOR TYPE hstore USING hash
 690 AS
 691         OPERATOR        1       = ,
 692         FUNCTION        1       hstore_hash(hstore);
 693
 694 -- GiST support
 695
 696 CREATE TYPE ghstore;
 697
 698 CREATE FUNCTION ghstore_in(cstring)
 699 RETURNS ghstore
 700 AS 'MODULE_PATHNAME'
 701 LANGUAGE C STRICT IMMUTABLE;
 702
 703 CREATE FUNCTION ghstore_out(ghstore)
 704 RETURNS cstring
 705 AS 'MODULE_PATHNAME'
 706 LANGUAGE C STRICT IMMUTABLE;
 707
 708 CREATE TYPE ghstore (
 709         INTERNALLENGTH = -1,
 710         INPUT = ghstore_in,
 711         OUTPUT = ghstore_out
 712 );
 713
 714 CREATE FUNCTION ghstore_compress(internal)
 715 RETURNS internal
 716 AS 'MODULE_PATHNAME'
 717 LANGUAGE C IMMUTABLE STRICT;
 718
 719 CREATE FUNCTION ghstore_decompress(internal)
 720 RETURNS internal
 721 AS 'MODULE_PATHNAME'
 722 LANGUAGE C IMMUTABLE STRICT;
 723
 724 CREATE FUNCTION ghstore_penalty(internal,internal,internal)
 725 RETURNS internal
 726 AS 'MODULE_PATHNAME'
 727 LANGUAGE C IMMUTABLE STRICT;
 728
 729 CREATE FUNCTION ghstore_picksplit(internal, internal)
 730 RETURNS internal
 731 AS 'MODULE_PATHNAME'
 732 LANGUAGE C IMMUTABLE STRICT;
 733
 734 CREATE FUNCTION ghstore_union(internal, internal)
 735 RETURNS internal
 736 AS 'MODULE_PATHNAME'
 737 LANGUAGE C IMMUTABLE STRICT;
 738
 739 CREATE FUNCTION ghstore_same(internal, internal, internal)
 740 RETURNS internal
 741 AS 'MODULE_PATHNAME'
 742 LANGUAGE C IMMUTABLE STRICT;
 743
 744 CREATE FUNCTION ghstore_consistent(internal,internal,int,oid,internal)
 745 RETURNS bool
 746 AS 'MODULE_PATHNAME'
 747 LANGUAGE C IMMUTABLE STRICT;
 748
 749 CREATE OPERATOR CLASS gist_hstore_ops
 750 DEFAULT FOR TYPE hstore USING gist
 751 AS
 752         OPERATOR        7       @> ,
 753         OPERATOR        9       ?(hstore,text) ,
 754         OPERATOR        10      ?|(hstore,text[]) ,
 755         OPERATOR        11      ?&(hstore,text[]) ,
 756         --OPERATOR        8       <@ ,
 757         OPERATOR        13      @ ,
 758         --OPERATOR        14      ~ ,
 759         FUNCTION        1       ghstore_consistent (internal, internal, int, oid, internal),
 760         FUNCTION        2       ghstore_union (internal, internal),
 761         FUNCTION        3       ghstore_compress (internal),
 762         FUNCTION        4       ghstore_decompress (internal),
 763         FUNCTION        5       ghstore_penalty (internal, internal, internal),
 764         FUNCTION        6       ghstore_picksplit (internal, internal),
 765         FUNCTION        7       ghstore_same (internal, internal, internal),
 766         STORAGE         ghstore;
 767
 768 -- GIN support: default opclass
 769
 770 CREATE FUNCTION gin_extract_hstore(internal, internal)
 771 RETURNS internal
 772 AS 'MODULE_PATHNAME'
 773 LANGUAGE C IMMUTABLE STRICT;
 774
 775 CREATE FUNCTION gin_extract_hstore_query(internal, internal, int2, internal, internal)
 776 RETURNS internal
 777 AS 'MODULE_PATHNAME'
 778 LANGUAGE C IMMUTABLE STRICT;
 779
 780 CREATE FUNCTION gin_consistent_hstore(internal, int2, internal, int4, internal, internal)
 781 RETURNS bool
 782 AS 'MODULE_PATHNAME'
 783 LANGUAGE C IMMUTABLE STRICT;
 784
 785 CREATE OPERATOR CLASS gin_hstore_ops
 786 DEFAULT FOR TYPE hstore USING gin
 787 AS
 788         OPERATOR        7       @>,
 789         OPERATOR        9       ?(hstore,text),
 790         OPERATOR        10      ?|(hstore,text[]),
 791         OPERATOR        11      ?&(hstore,text[]),
 792         FUNCTION        1       bttextcmp(text,text),
 793         FUNCTION        2       gin_extract_hstore(internal, internal),
 794         FUNCTION        3       gin_extract_hstore_query(internal, internal, int2, internal, internal),
 795         FUNCTION        4       gin_consistent_hstore(internal, int2, internal, int4, internal, internal),
 796         STORAGE         text;
 797
 798 -- GIN support: hash based opclass
 799
 800 CREATE FUNCTION gin_extract_hstore_hash(internal, internal)
 801 RETURNS internal
 802 AS 'MODULE_PATHNAME'
 803 LANGUAGE C IMMUTABLE STRICT;
 804
 805 CREATE FUNCTION gin_extract_hstore_hash_query(internal, internal, int2, internal, internal)
 806 RETURNS internal
 807 AS 'MODULE_PATHNAME'
 808 LANGUAGE C IMMUTABLE STRICT;
 809
 810 CREATE FUNCTION gin_consistent_hstore_hash(internal, int2, internal, int4, internal, internal)
 811 RETURNS bool
 812 AS 'MODULE_PATHNAME'
 813 LANGUAGE C IMMUTABLE STRICT;
 814
 815 CREATE OPERATOR CLASS gin_hstore_hash_ops
 816 FOR TYPE hstore USING gin
 817 AS
 818         OPERATOR        7       @>,
 819         FUNCTION        1       btint4cmp(int4,int4),
 820         FUNCTION        2       gin_extract_hstore_hash(internal, internal),
 821         FUNCTION        3       gin_extract_hstore_hash_query(internal, internal, int2, internal, internal),
 822         FUNCTION        4       gin_consistent_hstore_hash(internal, int2, internal, int4, internal, internal),
 823         STORAGE         int4;
 824
 825 -- output
 826
 827 CREATE FUNCTION hstore_print(hstore,
 828                                                          pretty_print bool DEFAULT false,
 829                                                          array_curly_braces bool DEFAULT false,
 830                                                          root_hash_decorated bool DEFAULT false,
 831                                                          json bool DEFAULT false,
 832                                                          loose bool DEFAULT false)
 833 RETURNS text
 834 AS 'MODULE_PATHNAME', 'hstore_print'
 835 LANGUAGE C IMMUTABLE STRICT;
 836
 837
 838