granicus.if.org Git - postgresql/blob - contrib/intarray/intarray--1.0.sql

   1 /* contrib/intarray/intarray--1.0.sql */
   2
   3 -- complain if script is sourced in psql, rather than via CREATE EXTENSION
   4 \echo Use "CREATE EXTENSION intarray" to load this file. \quit
   5
   6 --
   7 -- Create the user-defined type for the 1-D integer arrays (_int4)
   8 --
   9
  10 -- Query type
  11 CREATE FUNCTION bqarr_in(cstring)
  12 RETURNS query_int
  13 AS 'MODULE_PATHNAME'
  14 LANGUAGE C STRICT IMMUTABLE;
  15
  16 CREATE FUNCTION bqarr_out(query_int)
  17 RETURNS cstring
  18 AS 'MODULE_PATHNAME'
  19 LANGUAGE C STRICT IMMUTABLE;
  20
  21 CREATE TYPE query_int (
  22         INTERNALLENGTH = -1,
  23         INPUT = bqarr_in,
  24         OUTPUT = bqarr_out
  25 );
  26
  27 --only for debug
  28 CREATE FUNCTION querytree(query_int)
  29 RETURNS text
  30 AS 'MODULE_PATHNAME'
  31 LANGUAGE C STRICT IMMUTABLE;
  32
  33
  34 CREATE FUNCTION boolop(_int4, query_int)
  35 RETURNS bool
  36 AS 'MODULE_PATHNAME'
  37 LANGUAGE C STRICT IMMUTABLE;
  38
  39 COMMENT ON FUNCTION boolop(_int4, query_int) IS 'boolean operation with array';
  40
  41 CREATE FUNCTION rboolop(query_int, _int4)
  42 RETURNS bool
  43 AS 'MODULE_PATHNAME'
  44 LANGUAGE C STRICT IMMUTABLE;
  45
  46 COMMENT ON FUNCTION rboolop(query_int, _int4) IS 'boolean operation with array';
  47
  48 CREATE OPERATOR @@ (
  49         LEFTARG = _int4,
  50         RIGHTARG = query_int,
  51         PROCEDURE = boolop,
  52         COMMUTATOR = '~~',
  53         RESTRICT = contsel,
  54         JOIN = contjoinsel
  55 );
  56
  57 CREATE OPERATOR ~~ (
  58         LEFTARG = query_int,
  59         RIGHTARG = _int4,
  60         PROCEDURE = rboolop,
  61         COMMUTATOR = '@@',
  62         RESTRICT = contsel,
  63         JOIN = contjoinsel
  64 );
  65
  66
  67 --
  68 -- External C-functions for R-tree methods
  69 --
  70
  71 -- Comparison methods
  72
  73 CREATE FUNCTION _int_contains(_int4, _int4)
  74 RETURNS bool
  75 AS 'MODULE_PATHNAME'
  76 LANGUAGE C STRICT IMMUTABLE;
  77
  78 COMMENT ON FUNCTION _int_contains(_int4, _int4) IS 'contains';
  79
  80 CREATE FUNCTION _int_contained(_int4, _int4)
  81 RETURNS bool
  82 AS 'MODULE_PATHNAME'
  83 LANGUAGE C STRICT IMMUTABLE;
  84
  85 COMMENT ON FUNCTION _int_contained(_int4, _int4) IS 'contained in';
  86
  87 CREATE FUNCTION _int_overlap(_int4, _int4)
  88 RETURNS bool
  89 AS 'MODULE_PATHNAME'
  90 LANGUAGE C STRICT IMMUTABLE;
  91
  92 COMMENT ON FUNCTION _int_overlap(_int4, _int4) IS 'overlaps';
  93
  94 CREATE FUNCTION _int_same(_int4, _int4)
  95 RETURNS bool
  96 AS 'MODULE_PATHNAME'
  97 LANGUAGE C STRICT IMMUTABLE;
  98
  99 COMMENT ON FUNCTION _int_same(_int4, _int4) IS 'same as';
 100
 101 CREATE FUNCTION _int_different(_int4, _int4)
 102 RETURNS bool
 103 AS 'MODULE_PATHNAME'
 104 LANGUAGE C STRICT IMMUTABLE;
 105
 106 COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different';
 107
 108 -- support routines for indexing
 109
 110 CREATE FUNCTION _int_union(_int4, _int4)
 111 RETURNS _int4
 112 AS 'MODULE_PATHNAME'
 113 LANGUAGE C STRICT IMMUTABLE;
 114
 115 CREATE FUNCTION _int_inter(_int4, _int4)
 116 RETURNS _int4
 117 AS 'MODULE_PATHNAME'
 118 LANGUAGE C STRICT IMMUTABLE;
 119
 120 --
 121 -- OPERATORS
 122 --
 123
 124 CREATE OPERATOR && (
 125         LEFTARG = _int4,
 126         RIGHTARG = _int4,
 127         PROCEDURE = _int_overlap,
 128         COMMUTATOR = '&&',
 129         RESTRICT = contsel,
 130         JOIN = contjoinsel
 131 );
 132
 133 --CREATE OPERATOR = (
 134 --      LEFTARG = _int4,
 135 --      RIGHTARG = _int4,
 136 --      PROCEDURE = _int_same,
 137 --      COMMUTATOR = '=',
 138 --      NEGATOR = '<>',
 139 --      RESTRICT = eqsel,
 140 --      JOIN = eqjoinsel,
 141 --      SORT1 = '<',
 142 --      SORT2 = '<'
 143 --);
 144
 145 --CREATE OPERATOR <> (
 146 --      LEFTARG = _int4,
 147 --      RIGHTARG = _int4,
 148 --      PROCEDURE = _int_different,
 149 --      COMMUTATOR = '<>',
 150 --      NEGATOR = '=',
 151 --      RESTRICT = neqsel,
 152 --      JOIN = neqjoinsel
 153 --);
 154
 155 CREATE OPERATOR @> (
 156         LEFTARG = _int4,
 157         RIGHTARG = _int4,
 158         PROCEDURE = _int_contains,
 159         COMMUTATOR = '<@',
 160         RESTRICT = contsel,
 161         JOIN = contjoinsel
 162 );
 163
 164 CREATE OPERATOR <@ (
 165         LEFTARG = _int4,
 166         RIGHTARG = _int4,
 167         PROCEDURE = _int_contained,
 168         COMMUTATOR = '@>',
 169         RESTRICT = contsel,
 170         JOIN = contjoinsel
 171 );
 172
 173 -- obsolete:
 174 CREATE OPERATOR @ (
 175         LEFTARG = _int4,
 176         RIGHTARG = _int4,
 177         PROCEDURE = _int_contains,
 178         COMMUTATOR = '~',
 179         RESTRICT = contsel,
 180         JOIN = contjoinsel
 181 );
 182
 183 CREATE OPERATOR ~ (
 184         LEFTARG = _int4,
 185         RIGHTARG = _int4,
 186         PROCEDURE = _int_contained,
 187         COMMUTATOR = '@',
 188         RESTRICT = contsel,
 189         JOIN = contjoinsel
 190 );
 191
 192 --------------
 193 CREATE FUNCTION intset(int4)
 194 RETURNS _int4
 195 AS 'MODULE_PATHNAME'
 196 LANGUAGE C STRICT IMMUTABLE;
 197
 198 CREATE FUNCTION icount(_int4)
 199 RETURNS int4
 200 AS 'MODULE_PATHNAME'
 201 LANGUAGE C STRICT IMMUTABLE;
 202
 203 CREATE OPERATOR # (
 204         RIGHTARG = _int4,
 205         PROCEDURE = icount
 206 );
 207
 208 CREATE FUNCTION sort(_int4, text)
 209 RETURNS _int4
 210 AS 'MODULE_PATHNAME'
 211 LANGUAGE C STRICT IMMUTABLE;
 212
 213 CREATE FUNCTION sort(_int4)
 214 RETURNS _int4
 215 AS 'MODULE_PATHNAME'
 216 LANGUAGE C STRICT IMMUTABLE;
 217
 218 CREATE FUNCTION sort_asc(_int4)
 219 RETURNS _int4
 220 AS 'MODULE_PATHNAME'
 221 LANGUAGE C STRICT IMMUTABLE;
 222
 223 CREATE FUNCTION sort_desc(_int4)
 224 RETURNS _int4
 225 AS 'MODULE_PATHNAME'
 226 LANGUAGE C STRICT IMMUTABLE;
 227
 228 CREATE FUNCTION uniq(_int4)
 229 RETURNS _int4
 230 AS 'MODULE_PATHNAME'
 231 LANGUAGE C STRICT IMMUTABLE;
 232
 233 CREATE FUNCTION idx(_int4, int4)
 234 RETURNS int4
 235 AS 'MODULE_PATHNAME'
 236 LANGUAGE C STRICT IMMUTABLE;
 237
 238 CREATE OPERATOR # (
 239         LEFTARG = _int4,
 240         RIGHTARG = int4,
 241         PROCEDURE = idx
 242 );
 243
 244 CREATE FUNCTION subarray(_int4, int4, int4)
 245 RETURNS _int4
 246 AS 'MODULE_PATHNAME'
 247 LANGUAGE C STRICT IMMUTABLE;
 248
 249 CREATE FUNCTION subarray(_int4, int4)
 250 RETURNS _int4
 251 AS 'MODULE_PATHNAME'
 252 LANGUAGE C STRICT IMMUTABLE;
 253
 254 CREATE FUNCTION intarray_push_elem(_int4, int4)
 255 RETURNS _int4
 256 AS 'MODULE_PATHNAME'
 257 LANGUAGE C STRICT IMMUTABLE;
 258
 259 CREATE OPERATOR + (
 260         LEFTARG = _int4,
 261         RIGHTARG = int4,
 262         PROCEDURE = intarray_push_elem
 263 );
 264
 265 CREATE FUNCTION intarray_push_array(_int4, _int4)
 266 RETURNS _int4
 267 AS 'MODULE_PATHNAME'
 268 LANGUAGE C STRICT IMMUTABLE;
 269
 270 CREATE OPERATOR + (
 271         LEFTARG = _int4,
 272         RIGHTARG = _int4,
 273         COMMUTATOR = +,
 274         PROCEDURE = intarray_push_array
 275 );
 276
 277 CREATE FUNCTION intarray_del_elem(_int4, int4)
 278 RETURNS _int4
 279 AS 'MODULE_PATHNAME'
 280 LANGUAGE C STRICT IMMUTABLE;
 281
 282 CREATE OPERATOR - (
 283         LEFTARG = _int4,
 284         RIGHTARG = int4,
 285         PROCEDURE = intarray_del_elem
 286 );
 287
 288 CREATE FUNCTION intset_union_elem(_int4, int4)
 289 RETURNS _int4
 290 AS 'MODULE_PATHNAME'
 291 LANGUAGE C STRICT IMMUTABLE;
 292
 293 CREATE OPERATOR | (
 294         LEFTARG = _int4,
 295         RIGHTARG = int4,
 296         PROCEDURE = intset_union_elem
 297 );
 298
 299 CREATE OPERATOR | (
 300         LEFTARG = _int4,
 301         RIGHTARG = _int4,
 302         COMMUTATOR = |,
 303         PROCEDURE = _int_union
 304 );
 305
 306 CREATE FUNCTION intset_subtract(_int4, _int4)
 307 RETURNS _int4
 308 AS 'MODULE_PATHNAME'
 309 LANGUAGE C STRICT IMMUTABLE;
 310
 311 CREATE OPERATOR - (
 312         LEFTARG = _int4,
 313         RIGHTARG = _int4,
 314         PROCEDURE = intset_subtract
 315 );
 316
 317 CREATE OPERATOR & (
 318         LEFTARG = _int4,
 319         RIGHTARG = _int4,
 320         COMMUTATOR = &,
 321         PROCEDURE = _int_inter
 322 );
 323 --------------
 324
 325 -- define the GiST support methods
 326 CREATE FUNCTION g_int_consistent(internal,_int4,int,oid,internal)
 327 RETURNS bool
 328 AS 'MODULE_PATHNAME'
 329 LANGUAGE C IMMUTABLE STRICT;
 330
 331 CREATE FUNCTION g_int_compress(internal)
 332 RETURNS internal
 333 AS 'MODULE_PATHNAME'
 334 LANGUAGE C IMMUTABLE STRICT;
 335
 336 CREATE FUNCTION g_int_decompress(internal)
 337 RETURNS internal
 338 AS 'MODULE_PATHNAME'
 339 LANGUAGE C IMMUTABLE STRICT;
 340
 341 CREATE FUNCTION g_int_penalty(internal,internal,internal)
 342 RETURNS internal
 343 AS 'MODULE_PATHNAME'
 344 LANGUAGE C IMMUTABLE STRICT;
 345
 346 CREATE FUNCTION g_int_picksplit(internal, internal)
 347 RETURNS internal
 348 AS 'MODULE_PATHNAME'
 349 LANGUAGE C IMMUTABLE STRICT;
 350
 351 CREATE FUNCTION g_int_union(internal, internal)
 352 RETURNS _int4
 353 AS 'MODULE_PATHNAME'
 354 LANGUAGE C IMMUTABLE STRICT;
 355
 356 CREATE FUNCTION g_int_same(_int4, _int4, internal)
 357 RETURNS internal
 358 AS 'MODULE_PATHNAME'
 359 LANGUAGE C IMMUTABLE STRICT;
 360
 361
 362 -- Create the operator class for indexing
 363
 364 CREATE OPERATOR CLASS gist__int_ops
 365 DEFAULT FOR TYPE _int4 USING gist AS
 366         OPERATOR        3       &&,
 367         OPERATOR        6       = (anyarray, anyarray),
 368         OPERATOR        7       @>,
 369         OPERATOR        8       <@,
 370         OPERATOR        13      @,
 371         OPERATOR        14      ~,
 372         OPERATOR        20      @@ (_int4, query_int),
 373         FUNCTION        1       g_int_consistent (internal, _int4, int, oid, internal),
 374         FUNCTION        2       g_int_union (internal, internal),
 375         FUNCTION        3       g_int_compress (internal),
 376         FUNCTION        4       g_int_decompress (internal),
 377         FUNCTION        5       g_int_penalty (internal, internal, internal),
 378         FUNCTION        6       g_int_picksplit (internal, internal),
 379         FUNCTION        7       g_int_same (_int4, _int4, internal);
 380
 381
 382 ---------------------------------------------
 383 -- intbig
 384 ---------------------------------------------
 385 -- define the GiST support methods
 386
 387 CREATE FUNCTION _intbig_in(cstring)
 388 RETURNS intbig_gkey
 389 AS 'MODULE_PATHNAME'
 390 LANGUAGE C STRICT IMMUTABLE;
 391
 392 CREATE FUNCTION _intbig_out(intbig_gkey)
 393 RETURNS cstring
 394 AS 'MODULE_PATHNAME'
 395 LANGUAGE C STRICT IMMUTABLE;
 396
 397 CREATE TYPE intbig_gkey (
 398         INTERNALLENGTH = -1,
 399         INPUT = _intbig_in,
 400         OUTPUT = _intbig_out
 401 );
 402
 403 CREATE FUNCTION g_intbig_consistent(internal,internal,int,oid,internal)
 404 RETURNS bool
 405 AS 'MODULE_PATHNAME'
 406 LANGUAGE C IMMUTABLE STRICT;
 407
 408 CREATE FUNCTION g_intbig_compress(internal)
 409 RETURNS internal
 410 AS 'MODULE_PATHNAME'
 411 LANGUAGE C IMMUTABLE STRICT;
 412
 413 CREATE FUNCTION g_intbig_decompress(internal)
 414 RETURNS internal
 415 AS 'MODULE_PATHNAME'
 416 LANGUAGE C IMMUTABLE STRICT;
 417
 418 CREATE FUNCTION g_intbig_penalty(internal,internal,internal)
 419 RETURNS internal
 420 AS 'MODULE_PATHNAME'
 421 LANGUAGE C IMMUTABLE STRICT;
 422
 423 CREATE FUNCTION g_intbig_picksplit(internal, internal)
 424 RETURNS internal
 425 AS 'MODULE_PATHNAME'
 426 LANGUAGE C IMMUTABLE STRICT;
 427
 428 CREATE FUNCTION g_intbig_union(internal, internal)
 429 RETURNS _int4
 430 AS 'MODULE_PATHNAME'
 431 LANGUAGE C IMMUTABLE STRICT;
 432
 433 CREATE FUNCTION g_intbig_same(internal, internal, internal)
 434 RETURNS internal
 435 AS 'MODULE_PATHNAME'
 436 LANGUAGE C IMMUTABLE STRICT;
 437
 438 -- register the opclass for indexing (not as default)
 439
 440 CREATE OPERATOR CLASS gist__intbig_ops
 441 FOR TYPE _int4 USING gist
 442 AS
 443         OPERATOR        3       &&,
 444         OPERATOR        6       = (anyarray, anyarray),
 445         OPERATOR        7       @>,
 446         OPERATOR        8       <@,
 447         OPERATOR        13      @,
 448         OPERATOR        14      ~,
 449         OPERATOR        20      @@ (_int4, query_int),
 450         FUNCTION        1       g_intbig_consistent (internal, internal, int, oid, internal),
 451         FUNCTION        2       g_intbig_union (internal, internal),
 452         FUNCTION        3       g_intbig_compress (internal),
 453         FUNCTION        4       g_intbig_decompress (internal),
 454         FUNCTION        5       g_intbig_penalty (internal, internal, internal),
 455         FUNCTION        6       g_intbig_picksplit (internal, internal),
 456         FUNCTION        7       g_intbig_same (internal, internal, internal),
 457         STORAGE         intbig_gkey;
 458
 459 --GIN
 460
 461 CREATE FUNCTION ginint4_queryextract(internal, internal, int2, internal, internal, internal, internal)
 462 RETURNS internal
 463 AS 'MODULE_PATHNAME'
 464 LANGUAGE C IMMUTABLE STRICT;
 465
 466 CREATE FUNCTION ginint4_consistent(internal, int2, internal, int4, internal, internal, internal, internal)
 467 RETURNS bool
 468 AS 'MODULE_PATHNAME'
 469 LANGUAGE C IMMUTABLE STRICT;
 470
 471 CREATE OPERATOR CLASS gin__int_ops
 472 FOR TYPE _int4 USING gin
 473 AS
 474         OPERATOR        3       &&,
 475         OPERATOR        6       = (anyarray, anyarray),
 476         OPERATOR        7       @>,
 477         OPERATOR        8       <@,
 478         OPERATOR        13      @,
 479         OPERATOR        14      ~,
 480         OPERATOR        20      @@ (_int4, query_int),
 481         FUNCTION        1       btint4cmp (int4, int4),
 482         FUNCTION        2       ginarrayextract (anyarray, internal, internal),
 483         FUNCTION        3       ginint4_queryextract (internal, internal, int2, internal, internal, internal, internal),
 484         FUNCTION        4       ginint4_consistent (internal, int2, internal, int4, internal, internal, internal, internal),
 485         STORAGE         int4;