nested hstore
[hstore.git] / hstore--1.3.sql
1 /* contrib/hstore/hstore--1.3.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