contrib/intarray/_int.sql.in

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