diff --git a/contrib/intarray/Makefile b/contrib/intarray/Makefile index 2505294..d99d977 100644 --- a/contrib/intarray/Makefile +++ b/contrib/intarray/Makefile @@ -5,8 +5,8 @@ OBJS = _int_bool.o _int_gist.o _int_op.o _int_tool.o \ _intbig_gist.o _int_gin.o _int_selfuncs.o $(WIN32RES) EXTENSION = intarray -DATA = intarray--1.2.sql intarray--1.1--1.2.sql intarray--1.0--1.1.sql \ - intarray--unpackaged--1.0.sql +DATA = intarray--1.3.sql intarray--1.2-1.3.sql intarray--1.1--1.2.sql \ + intarray--1.0--1.1.sql intarray--unpackaged--1.0.sql PGFILEDESC = "intarray - functions and operators for arrays of integers" REGRESS = _int diff --git a/contrib/intarray/_int.h b/contrib/intarray/_int.h index b689eb7..87d21e9 100644 --- a/contrib/intarray/_int.h +++ b/contrib/intarray/_int.h @@ -8,7 +8,15 @@ #include "utils/memutils.h" /* number ranges for compression */ -#define MAXNUMRANGE 100 +#define G_INT_NUMRANGES_DEFAULT 100 +#define G_INT_NUMRANGES_MAX 1000 + +/* gist_int_ops opclass options */ +typedef struct IntArrayOptions +{ + int32 vl_len_; /* varlena header (do not touch directly!) */ + int num_ranges; /* number of ranges */ +} IntArrayOptions; /* useful macros for accessing int4 arrays */ #define ARRPTR(x) ( (int32 *) ARR_DATA_PTR(x) ) @@ -47,15 +55,14 @@ /* bigint defines */ -#define SIGLENINT 63 /* >122 => key will toast, so very slow!!! */ -#define SIGLEN ( sizeof(int)*SIGLENINT ) -#define SIGLENBIT (SIGLEN*BITS_PER_BYTE) +#define SIGLEN_DEFAULT (63 * 4) +#define SIGLEN_MAX (122 * 4) /* key will toast, so very slow!!! */ +#define SIGLENBIT(siglen) ((siglen) * BITS_PER_BYTE) -typedef char BITVEC[SIGLEN]; typedef char *BITVECP; -#define LOOPBYTE \ - for(i=0;i> ( (i) % BITS_PER_BYTE )) & 0x01 ) -#define HASHVAL(val) (((unsigned int)(val)) % SIGLENBIT) -#define HASH(sign, val) SETBIT((sign), HASHVAL(val)) +#define HASHVAL(val, siglen) (((unsigned int)(val)) % SIGLENBIT(siglen)) +#define HASH(sign, val, siglen) SETBIT((sign), HASHVAL(val, siglen)) + +/* gist_intbig_ops opclass options */ +typedef struct IntArrayBigOptions +{ + int32 vl_len_; /* varlena header (do not touch directly!) */ + int siglen; /* signature length in bytes */ +} IntArrayBigOptions; /* * type of index key @@ -81,7 +95,7 @@ typedef struct #define ISALLTRUE(x) ( ((GISTTYPE*)x)->flag & ALLISTRUE ) #define GTHDRSIZE (VARHDRSZ + sizeof(int32)) -#define CALCGTSIZE(flag) ( GTHDRSIZE+(((flag) & ALLISTRUE) ? 0 : SIGLEN) ) +#define CALCGTSIZE(flag, siglen) ( GTHDRSIZE+(((flag) & ALLISTRUE) ? 0 : (siglen)) ) #define GETSIGN(x) ( (BITVECP)( (char*)x+GTHDRSIZE ) ) @@ -109,7 +123,7 @@ bool inner_int_contains(ArrayType *a, ArrayType *b); ArrayType *inner_int_union(ArrayType *a, ArrayType *b); ArrayType *inner_int_inter(ArrayType *a, ArrayType *b); void rt__int_size(ArrayType *a, float *size); -void gensign(BITVEC sign, int *a, int len); +void gensign(BITVECP sign, int *a, int len, int siglen); /***************************************************************************** @@ -155,7 +169,7 @@ typedef struct QUERYTYPE #define PG_GETARG_QUERYTYPE_P(n) DatumGetQueryTypeP(PG_GETARG_DATUM(n)) #define PG_GETARG_QUERYTYPE_P_COPY(n) DatumGetQueryTypePCopy(PG_GETARG_DATUM(n)) -bool signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot); +bool signconsistent(QUERYTYPE *query, BITVECP sign, int siglen, bool calcnot); bool execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot); bool gin_bool_consistent(QUERYTYPE *query, bool *check); diff --git a/contrib/intarray/_int_bool.c b/contrib/intarray/_int_bool.c index 91e2a80..4e7d55a 100644 --- a/contrib/intarray/_int_bool.c +++ b/contrib/intarray/_int_bool.c @@ -233,7 +233,7 @@ typedef struct * is there value 'val' in (sorted) array or not ? */ static bool -checkcondition_arr(void *checkval, ITEM *item) +checkcondition_arr(void *checkval, ITEM *item, void *options) { int32 *StopLow = ((CHKVAL *) checkval)->arrb; int32 *StopHigh = ((CHKVAL *) checkval)->arre; @@ -255,42 +255,42 @@ checkcondition_arr(void *checkval, ITEM *item) } static bool -checkcondition_bit(void *checkval, ITEM *item) +checkcondition_bit(void *checkval, ITEM *item, void *siglen) { - return GETBIT(checkval, HASHVAL(item->val)); + return GETBIT(checkval, HASHVAL(item->val, (int)(intptr_t) siglen)); } /* * evaluate boolean expression, using chkcond() to test the primitive cases */ static bool -execute(ITEM *curitem, void *checkval, bool calcnot, - bool (*chkcond) (void *checkval, ITEM *item)) +execute(ITEM *curitem, void *checkval, void *options, bool calcnot, + bool (*chkcond) (void *checkval, ITEM *item, void *options)) { /* since this function recurses, it could be driven to stack overflow */ check_stack_depth(); if (curitem->type == VAL) - return (*chkcond) (checkval, curitem); + return (*chkcond) (checkval, curitem, options); else if (curitem->val == (int32) '!') { return calcnot ? - ((execute(curitem - 1, checkval, calcnot, chkcond)) ? false : true) + ((execute(curitem - 1, checkval, options, calcnot, chkcond)) ? false : true) : true; } else if (curitem->val == (int32) '&') { - if (execute(curitem + curitem->left, checkval, calcnot, chkcond)) - return execute(curitem - 1, checkval, calcnot, chkcond); + if (execute(curitem + curitem->left, checkval, options, calcnot, chkcond)) + return execute(curitem - 1, checkval, options, calcnot, chkcond); else return false; } else { /* |-operator */ - if (execute(curitem + curitem->left, checkval, calcnot, chkcond)) + if (execute(curitem + curitem->left, checkval, options, calcnot, chkcond)) return true; else - return execute(curitem - 1, checkval, calcnot, chkcond); + return execute(curitem - 1, checkval, options, calcnot, chkcond); } } @@ -298,10 +298,10 @@ execute(ITEM *curitem, void *checkval, bool calcnot, * signconsistent & execconsistent called by *_consistent */ bool -signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot) +signconsistent(QUERYTYPE *query, BITVECP sign, int siglen, bool calcnot) { return execute(GETQUERY(query) + query->size - 1, - (void *) sign, calcnot, + (void *) sign, (void *)(intptr_t) siglen, calcnot, checkcondition_bit); } @@ -315,7 +315,7 @@ execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot) chkval.arrb = ARRPTR(array); chkval.arre = chkval.arrb + ARRNELEMS(array); return execute(GETQUERY(query) + query->size - 1, - (void *) &chkval, calcnot, + (void *) &chkval, NULL, calcnot, checkcondition_arr); } @@ -326,7 +326,7 @@ typedef struct } GinChkVal; static bool -checkcondition_gin(void *checkval, ITEM *item) +checkcondition_gin(void *checkval, ITEM *item, void *options) { GinChkVal *gcv = (GinChkVal *) checkval; @@ -357,7 +357,7 @@ gin_bool_consistent(QUERYTYPE *query, bool *check) } return execute(GETQUERY(query) + query->size - 1, - (void *) &gcv, true, + (void *) &gcv, NULL, true, checkcondition_gin); } @@ -429,7 +429,7 @@ boolop(PG_FUNCTION_ARGS) chkval.arrb = ARRPTR(val); chkval.arre = chkval.arrb + ARRNELEMS(val); result = execute(GETQUERY(query) + query->size - 1, - &chkval, true, + &chkval, NULL, true, checkcondition_arr); pfree(val); diff --git a/contrib/intarray/_int_gist.c b/contrib/intarray/_int_gist.c index 911d180..9de7f55 100644 --- a/contrib/intarray/_int_gist.c +++ b/contrib/intarray/_int_gist.c @@ -6,6 +6,7 @@ #include #include "access/gist.h" +#include "access/reloptions.h" #include "access/stratnum.h" #include "_int.h" @@ -22,6 +23,7 @@ PG_FUNCTION_INFO_V1(g_int_penalty); PG_FUNCTION_INFO_V1(g_int_picksplit); PG_FUNCTION_INFO_V1(g_int_union); PG_FUNCTION_INFO_V1(g_int_same); +PG_FUNCTION_INFO_V1(g_int_options); /* @@ -139,6 +141,7 @@ Datum g_int_compress(PG_FUNCTION_ARGS) { GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + IntArrayOptions *opts = (IntArrayOptions *) PG_GETARG_POINTER(1); GISTENTRY *retval; ArrayType *r; int len; @@ -153,9 +156,9 @@ g_int_compress(PG_FUNCTION_ARGS) CHECKARRVALID(r); PREPAREARR(r); - if (ARRNELEMS(r) >= 2 * MAXNUMRANGE) + if (ARRNELEMS(r) >= 2 * opts->num_ranges) elog(NOTICE, "input array is too big (%d maximum allowed, %d current), use gist__intbig_ops opclass instead", - 2 * MAXNUMRANGE - 1, ARRNELEMS(r)); + 2 * opts->num_ranges - 1, ARRNELEMS(r)); retval = palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(r), @@ -178,7 +181,7 @@ g_int_compress(PG_FUNCTION_ARGS) PG_RETURN_POINTER(entry); } - if ((len = ARRNELEMS(r)) >= 2 * MAXNUMRANGE) + if ((len = ARRNELEMS(r)) >= 2 * opts->num_ranges) { /* compress */ if (r == (ArrayType *) DatumGetPointer(entry->key)) r = DatumGetArrayTypePCopy(entry->key); @@ -191,7 +194,7 @@ g_int_compress(PG_FUNCTION_ARGS) len *= 2; cand = 1; - while (len > MAXNUMRANGE * 2) + while (len > opts->num_ranges * 2) { min = INT_MAX; for (i = 2; i < len; i += 2) @@ -217,6 +220,7 @@ Datum g_int_decompress(PG_FUNCTION_ARGS) { GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + IntArrayOptions *opts = (IntArrayOptions *) PG_GETARG_POINTER(1); GISTENTRY *retval; ArrayType *r; int *dr, @@ -245,7 +249,7 @@ g_int_decompress(PG_FUNCTION_ARGS) lenin = ARRNELEMS(in); - if (lenin < 2 * MAXNUMRANGE) + if (lenin < 2 * opts->num_ranges) { /* not compressed value */ if (in != (ArrayType *) DatumGetPointer(entry->key)) { @@ -542,3 +546,20 @@ g_int_picksplit(PG_FUNCTION_ARGS) PG_RETURN_POINTER(v); } + +Datum +g_int_options(PG_FUNCTION_ARGS) +{ + Datum raw_options = PG_GETARG_DATUM(0); + bool validate = PG_GETARG_BOOL(1); + relopt_int siglen = + { {"numranges", "number of ranges for compression", 0, 0, 9, RELOPT_TYPE_INT }, + G_INT_NUMRANGES_DEFAULT, 1, G_INT_NUMRANGES_MAX }; + relopt_gen *optgen[] = { &siglen.gen }; + int offsets[] = { offsetof(IntArrayOptions, num_ranges) }; + IntArrayOptions *options = + parseAndFillLocalRelOptions(raw_options, optgen, offsets, 1, + sizeof(IntArrayOptions), validate); + + PG_RETURN_POINTER(options); +} diff --git a/contrib/intarray/_int_tool.c b/contrib/intarray/_int_tool.c index ee8fb64..d7c5317 100644 --- a/contrib/intarray/_int_tool.c +++ b/contrib/intarray/_int_tool.c @@ -313,14 +313,14 @@ _int_unique(ArrayType *r) } void -gensign(BITVEC sign, int *a, int len) +gensign(BITVECP sign, int *a, int len, int siglen) { int i; /* we assume that the sign vector is previously zeroed */ for (i = 0; i < len; i++) { - HASH(sign, *a); + HASH(sign, *a, siglen); a++; } } diff --git a/contrib/intarray/_intbig_gist.c b/contrib/intarray/_intbig_gist.c index de7bc82..4d2b3a2 100644 --- a/contrib/intarray/_intbig_gist.c +++ b/contrib/intarray/_intbig_gist.c @@ -4,6 +4,7 @@ #include "postgres.h" #include "access/gist.h" +#include "access/reloptions.h" #include "access/stratnum.h" #include "_int.h" @@ -19,6 +20,7 @@ PG_FUNCTION_INFO_V1(g_intbig_penalty); PG_FUNCTION_INFO_V1(g_intbig_picksplit); PG_FUNCTION_INFO_V1(g_intbig_union); PG_FUNCTION_INFO_V1(g_intbig_same); +PG_FUNCTION_INFO_V1(g_intbig_options); /* Number of one-bits in an unsigned byte */ static const uint8 number_of_ones[256] = { @@ -61,12 +63,33 @@ _intbig_out(PG_FUNCTION_ARGS) PG_RETURN_DATUM(0); } +static GISTTYPE * +_intbig_alloc(bool allistrue, int siglen, BITVECP sign) +{ + int flag = allistrue ? ALLISTRUE : 0; + int size = CALCGTSIZE(flag, siglen); + GISTTYPE *res = (GISTTYPE *) palloc(size); + + SET_VARSIZE(res, size); + res->flag = flag; + + if (!allistrue) + { + if (sign) + memcpy(GETSIGN(res), sign, siglen); + else + memset(GETSIGN(res), 0, siglen); + } + + return res; +} + /********************************************************************* ** intbig functions *********************************************************************/ static bool -_intbig_overlap(GISTTYPE *a, ArrayType *b) +_intbig_overlap(GISTTYPE *a, ArrayType *b, int siglen) { int num = ARRNELEMS(b); int32 *ptr = ARRPTR(b); @@ -75,7 +98,7 @@ _intbig_overlap(GISTTYPE *a, ArrayType *b) while (num--) { - if (GETBIT(GETSIGN(a), HASHVAL(*ptr))) + if (GETBIT(GETSIGN(a), HASHVAL(*ptr, siglen))) return true; ptr++; } @@ -84,7 +107,7 @@ _intbig_overlap(GISTTYPE *a, ArrayType *b) } static bool -_intbig_contains(GISTTYPE *a, ArrayType *b) +_intbig_contains(GISTTYPE *a, ArrayType *b, int siglen) { int num = ARRNELEMS(b); int32 *ptr = ARRPTR(b); @@ -93,7 +116,7 @@ _intbig_contains(GISTTYPE *a, ArrayType *b) while (num--) { - if (!GETBIT(GETSIGN(a), HASHVAL(*ptr))) + if (!GETBIT(GETSIGN(a), HASHVAL(*ptr, siglen))) return false; ptr++; } @@ -107,6 +130,8 @@ g_intbig_same(PG_FUNCTION_ARGS) GISTTYPE *a = (GISTTYPE *) PG_GETARG_POINTER(0); GISTTYPE *b = (GISTTYPE *) PG_GETARG_POINTER(1); bool *result = (bool *) PG_GETARG_POINTER(2); + IntArrayBigOptions *opts = (IntArrayBigOptions *) PG_GETARG_POINTER(3); + int siglen = opts->siglen; if (ISALLTRUE(a) && ISALLTRUE(b)) *result = true; @@ -121,7 +146,7 @@ g_intbig_same(PG_FUNCTION_ARGS) sb = GETSIGN(b); *result = true; - LOOPBYTE + LOOPBYTE(siglen) { if (sa[i] != sb[i]) { @@ -137,6 +162,8 @@ Datum g_intbig_compress(PG_FUNCTION_ARGS) { GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + IntArrayBigOptions *opts = (IntArrayBigOptions *) PG_GETARG_POINTER(1); + int siglen = opts->siglen; if (entry->leafkey) { @@ -144,7 +171,7 @@ g_intbig_compress(PG_FUNCTION_ARGS) ArrayType *in = DatumGetArrayTypeP(entry->key); int32 *ptr; int num; - GISTTYPE *res = (GISTTYPE *) palloc0(CALCGTSIZE(0)); + GISTTYPE *res = _intbig_alloc(false, siglen, NULL); CHECKARRVALID(in); if (ARRISEMPTY(in)) @@ -157,11 +184,10 @@ g_intbig_compress(PG_FUNCTION_ARGS) ptr = ARRPTR(in); num = ARRNELEMS(in); } - SET_VARSIZE(res, CALCGTSIZE(0)); while (num--) { - HASH(GETSIGN(res), *ptr); + HASH(GETSIGN(res), *ptr, siglen); ptr++; } @@ -182,16 +208,13 @@ g_intbig_compress(PG_FUNCTION_ARGS) BITVECP sign = GETSIGN(DatumGetPointer(entry->key)); GISTTYPE *res; - LOOPBYTE + LOOPBYTE(siglen) { if ((sign[i] & 0xff) != 0xff) PG_RETURN_POINTER(entry); } - res = (GISTTYPE *) palloc(CALCGTSIZE(ALLISTRUE)); - SET_VARSIZE(res, CALCGTSIZE(ALLISTRUE)); - res->flag = ALLISTRUE; - + res = _intbig_alloc(true, siglen, sign); retval = (GISTENTRY *) palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(res), entry->rel, entry->page, @@ -205,24 +228,24 @@ g_intbig_compress(PG_FUNCTION_ARGS) static int32 -sizebitvec(BITVECP sign) +sizebitvec(BITVECP sign, int siglen) { int32 size = 0, i; - LOOPBYTE + LOOPBYTE(siglen) size += number_of_ones[(unsigned char) sign[i]]; return size; } static int -hemdistsign(BITVECP a, BITVECP b) +hemdistsign(BITVECP a, BITVECP b, int siglen) { int i, diff, dist = 0; - LOOPBYTE + LOOPBYTE(siglen) { diff = (unsigned char) (a[i] ^ b[i]); dist += number_of_ones[diff]; @@ -231,19 +254,19 @@ hemdistsign(BITVECP a, BITVECP b) } static int -hemdist(GISTTYPE *a, GISTTYPE *b) +hemdist(GISTTYPE *a, GISTTYPE *b, int siglen) { if (ISALLTRUE(a)) { if (ISALLTRUE(b)) return 0; else - return SIGLENBIT - sizebitvec(GETSIGN(b)); + return SIGLENBIT(siglen) - sizebitvec(GETSIGN(b), siglen); } else if (ISALLTRUE(b)) - return SIGLENBIT - sizebitvec(GETSIGN(a)); + return SIGLENBIT(siglen) - sizebitvec(GETSIGN(a), siglen); - return hemdistsign(GETSIGN(a), GETSIGN(b)); + return hemdistsign(GETSIGN(a), GETSIGN(b), siglen); } Datum @@ -253,14 +276,14 @@ g_intbig_decompress(PG_FUNCTION_ARGS) } static int32 -unionkey(BITVECP sbase, GISTTYPE *add) +unionkey(BITVECP sbase, GISTTYPE *add, int siglen) { int32 i; BITVECP sadd = GETSIGN(add); if (ISALLTRUE(add)) return 1; - LOOPBYTE + LOOPBYTE(siglen) sbase[i] |= sadd[i]; return 0; } @@ -270,29 +293,23 @@ g_intbig_union(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); int *size = (int *) PG_GETARG_POINTER(1); - BITVEC base; - int32 i, - len; - int32 flag = 0; - GISTTYPE *result; + IntArrayBigOptions *opts = (IntArrayBigOptions *) PG_GETARG_POINTER(2); + int siglen = opts->siglen; + int32 i; + GISTTYPE *result = _intbig_alloc(false, siglen, NULL); + BITVECP base = GETSIGN(result); - MemSet((void *) base, 0, sizeof(BITVEC)); for (i = 0; i < entryvec->n; i++) { - if (unionkey(base, GETENTRY(entryvec, i))) + if (unionkey(base, GETENTRY(entryvec, i), siglen)) { - flag = ALLISTRUE; + result->flag |= ALLISTRUE; + SET_VARSIZE(result, CALCGTSIZE(ALLISTRUE, siglen)); break; } } - len = CALCGTSIZE(flag); - result = (GISTTYPE *) palloc(len); - SET_VARSIZE(result, len); - result->flag = flag; - if (!ISALLTRUE(result)) - memcpy((void *) GETSIGN(result), (void *) base, sizeof(BITVEC)); - *size = len; + *size = VARSIZE(result); PG_RETURN_POINTER(result); } @@ -305,8 +322,10 @@ g_intbig_penalty(PG_FUNCTION_ARGS) float *penalty = (float *) PG_GETARG_POINTER(2); GISTTYPE *origval = (GISTTYPE *) DatumGetPointer(origentry->key); GISTTYPE *newval = (GISTTYPE *) DatumGetPointer(newentry->key); + IntArrayBigOptions *opts = (IntArrayBigOptions *) PG_GETARG_POINTER(3); + int siglen = opts->siglen; - *penalty = hemdist(origval, newval); + *penalty = hemdist(origval, newval, siglen); PG_RETURN_POINTER(penalty); } @@ -329,6 +348,8 @@ g_intbig_picksplit(PG_FUNCTION_ARGS) { GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + IntArrayBigOptions *opts = (IntArrayBigOptions *) PG_GETARG_POINTER(2); + int siglen = opts->siglen; OffsetNumber k, j; GISTTYPE *datum_l, @@ -361,7 +382,7 @@ g_intbig_picksplit(PG_FUNCTION_ARGS) _k = GETENTRY(entryvec, k); for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) { - size_waste = hemdist(_k, GETENTRY(entryvec, j)); + size_waste = hemdist(_k, GETENTRY(entryvec, j), siglen); if (size_waste > waste) { waste = size_waste; @@ -383,32 +404,10 @@ g_intbig_picksplit(PG_FUNCTION_ARGS) } /* form initial .. */ - if (ISALLTRUE(GETENTRY(entryvec, seed_1))) - { - datum_l = (GISTTYPE *) palloc(GTHDRSIZE); - SET_VARSIZE(datum_l, GTHDRSIZE); - datum_l->flag = ALLISTRUE; - } - else - { - datum_l = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); - SET_VARSIZE(datum_l, GTHDRSIZE + SIGLEN); - datum_l->flag = 0; - memcpy((void *) GETSIGN(datum_l), (void *) GETSIGN(GETENTRY(entryvec, seed_1)), sizeof(BITVEC)); - } - if (ISALLTRUE(GETENTRY(entryvec, seed_2))) - { - datum_r = (GISTTYPE *) palloc(GTHDRSIZE); - SET_VARSIZE(datum_r, GTHDRSIZE); - datum_r->flag = ALLISTRUE; - } - else - { - datum_r = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); - SET_VARSIZE(datum_r, GTHDRSIZE + SIGLEN); - datum_r->flag = 0; - memcpy((void *) GETSIGN(datum_r), (void *) GETSIGN(GETENTRY(entryvec, seed_2)), sizeof(BITVEC)); - } + datum_l = _intbig_alloc(ISALLTRUE(GETENTRY(entryvec, seed_1)), siglen, + GETSIGN(GETENTRY(entryvec, seed_1))); + datum_r = _intbig_alloc(ISALLTRUE(GETENTRY(entryvec, seed_2)), siglen, + GETSIGN(GETENTRY(entryvec, seed_2))); maxoff = OffsetNumberNext(maxoff); /* sort before ... */ @@ -417,8 +416,8 @@ g_intbig_picksplit(PG_FUNCTION_ARGS) { costvector[j - 1].pos = j; _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l, _j); - size_beta = hemdist(datum_r, _j); + size_alpha = hemdist(datum_l, _j, siglen); + size_beta = hemdist(datum_r, _j, siglen); costvector[j - 1].cost = Abs(size_alpha - size_beta); } qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost); @@ -442,20 +441,20 @@ g_intbig_picksplit(PG_FUNCTION_ARGS) continue; } _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l, _j); - size_beta = hemdist(datum_r, _j); + size_alpha = hemdist(datum_l, _j, siglen); + size_beta = hemdist(datum_r, _j, siglen); if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.00001)) { if (ISALLTRUE(datum_l) || ISALLTRUE(_j)) { if (!ISALLTRUE(datum_l)) - MemSet((void *) union_l, 0xff, sizeof(BITVEC)); + MemSet((void *) union_l, 0xff, siglen); } else { ptr = GETSIGN(_j); - LOOPBYTE + LOOPBYTE(siglen) union_l[i] |= ptr[i]; } *left++ = j; @@ -466,12 +465,12 @@ g_intbig_picksplit(PG_FUNCTION_ARGS) if (ISALLTRUE(datum_r) || ISALLTRUE(_j)) { if (!ISALLTRUE(datum_r)) - MemSet((void *) union_r, 0xff, sizeof(BITVEC)); + MemSet((void *) union_r, 0xff, siglen); } else { ptr = GETSIGN(_j); - LOOPBYTE + LOOPBYTE(siglen) union_r[i] |= ptr[i]; } *right++ = j; @@ -497,6 +496,8 @@ g_intbig_consistent(PG_FUNCTION_ARGS) /* Oid subtype = PG_GETARG_OID(3); */ bool *recheck = (bool *) PG_GETARG_POINTER(4); + IntArrayBigOptions *opts = (IntArrayBigOptions *) PG_GETARG_POINTER(5); + int siglen = opts->siglen; bool retval; /* All cases served by this function are inexact */ @@ -509,6 +510,7 @@ g_intbig_consistent(PG_FUNCTION_ARGS) { retval = signconsistent((QUERYTYPE *) query, GETSIGN(DatumGetPointer(entry->key)), + siglen, false); PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(retval); @@ -519,7 +521,8 @@ g_intbig_consistent(PG_FUNCTION_ARGS) switch (strategy) { case RTOverlapStrategyNumber: - retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key), query); + retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key), + query, siglen); break; case RTSameStrategyNumber: if (GIST_LEAF(entry)) @@ -527,22 +530,18 @@ g_intbig_consistent(PG_FUNCTION_ARGS) int i, num = ARRNELEMS(query); int32 *ptr = ARRPTR(query); - BITVEC qp; - BITVECP dq, + BITVECP dq = palloc0(siglen), de; - memset(qp, 0, sizeof(BITVEC)); - while (num--) { - HASH(qp, *ptr); + HASH(dq, *ptr, siglen); ptr++; } de = GETSIGN((GISTTYPE *) DatumGetPointer(entry->key)); - dq = qp; retval = true; - LOOPBYTE + LOOPBYTE(siglen) { if (de[i] != dq[i]) { @@ -551,13 +550,16 @@ g_intbig_consistent(PG_FUNCTION_ARGS) } } + pfree(dq); } else - retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), query); + retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), + query, siglen); break; case RTContainsStrategyNumber: case RTOldContainsStrategyNumber: - retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), query); + retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), + query, siglen); break; case RTContainedByStrategyNumber: case RTOldContainedByStrategyNumber: @@ -566,22 +568,18 @@ g_intbig_consistent(PG_FUNCTION_ARGS) int i, num = ARRNELEMS(query); int32 *ptr = ARRPTR(query); - BITVEC qp; - BITVECP dq, + BITVECP dq = palloc0(siglen), de; - memset(qp, 0, sizeof(BITVEC)); - while (num--) { - HASH(qp, *ptr); + HASH(dq, *ptr, siglen); ptr++; } de = GETSIGN((GISTTYPE *) DatumGetPointer(entry->key)); - dq = qp; retval = true; - LOOPBYTE + LOOPBYTE(siglen) { if (de[i] & ~dq[i]) { @@ -591,7 +589,8 @@ g_intbig_consistent(PG_FUNCTION_ARGS) } } else - retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key), query); + retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key), + query, siglen); break; default: retval = false; @@ -599,3 +598,20 @@ g_intbig_consistent(PG_FUNCTION_ARGS) PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(retval); } + +Datum +g_intbig_options(PG_FUNCTION_ARGS) +{ + Datum raw_options = PG_GETARG_DATUM(0); + bool validate = PG_GETARG_BOOL(1); + relopt_int siglen = + { {"siglen", "signature length", 0, NoLock, 6, RELOPT_TYPE_INT }, + SIGLEN_DEFAULT, 1, SIGLEN_MAX }; + relopt_gen *optgen[] = { &siglen.gen }; + int offsets[] = { offsetof(IntArrayBigOptions, siglen) }; + IntArrayBigOptions *options = + parseAndFillLocalRelOptions(raw_options, optgen, offsets, 1, + sizeof(IntArrayBigOptions), validate); + + PG_RETURN_POINTER(options); +} diff --git a/contrib/intarray/intarray--1.2-1.3.sql b/contrib/intarray/intarray--1.2-1.3.sql new file mode 100644 index 0000000..c9b83ef --- /dev/null +++ b/contrib/intarray/intarray--1.2-1.3.sql @@ -0,0 +1,34 @@ +/* contrib/intarray/intarray--1.2--1.3.sql */ + +-- complain if script is sourced in psql, rather than via ALTER EXTENSION +\echo Use "ALTER EXTENSION intarray UPDATE TO '1.3'" to load this file. \quit + +-- Update procedure signatures the hard way. +-- We use to_regprocedure() so that query doesn't fail if run against 9.6beta1 definitions, +-- wherein the signatures have been updated already. In that case to_regprocedure() will +-- return NULL and no updates will happen. + +UPDATE pg_catalog.pg_proc SET + proargtypes = pg_catalog.array_to_string(newtypes::pg_catalog.oid[], ' ')::pg_catalog.oidvector, + pronargs = pg_catalog.array_length(newtypes, 1) +FROM (VALUES +(NULL::pg_catalog.text, NULL::pg_catalog.regtype[]), -- establish column types +('g_int_compress(internal)', '{internal,internal}'), +('g_int_decompress(internal)', '{internal,internal}'), +('g_intbig_consistent(internal,_int4,smallint,oid,internal)', '{internal,_int4,smallint,oid,internal,internal}'), +('g_intbig_compress(internal)', '{internal,internal}'), +('g_intbig_decompress(internal)', '{internal,internal}'), +('g_intbig_penalty(internal,internal,internal)', '{internal,internal,internal,internal}'), +('g_intbig_picksplit(internal,internal)', '{internal,internal,internal}'), +('g_intbig_union(internal,internal)', '{internal,internal,internal}'), +('g_intbig_same(intbig_gkey,intbig_gkey,internal)', '{intbig_gkey,intbig_gkey,internal,internal}') +) AS update_data (oldproc, newtypes) +WHERE oid = pg_catalog.to_regprocedure(oldproc); + +CREATE FUNCTION g_intbig_options(internal, boolean) +RETURNS internal +AS 'MODULE_PATHNAME', 'g_intbig_options' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +ALTER OPERATOR FAMILY gist__intbig_ops USING gist +ADD FUNCTION 10 (_int4) g_intbig_options (internal, boolean); diff --git a/contrib/intarray/intarray--1.2.sql b/contrib/intarray/intarray--1.2.sql deleted file mode 100644 index f10b53d..0000000 --- a/contrib/intarray/intarray--1.2.sql +++ /dev/null @@ -1,520 +0,0 @@ -/* contrib/intarray/intarray--1.2.sql */ - --- complain if script is sourced in psql, rather than via CREATE EXTENSION -\echo Use "CREATE EXTENSION intarray" to load this file. \quit - --- --- Create the user-defined type for the 1-D integer arrays (_int4) --- - --- Query type -CREATE FUNCTION bqarr_in(cstring) -RETURNS query_int -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION bqarr_out(query_int) -RETURNS cstring -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE TYPE query_int ( - INTERNALLENGTH = -1, - INPUT = bqarr_in, - OUTPUT = bqarr_out -); - ---only for debug -CREATE FUNCTION querytree(query_int) -RETURNS text -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - - -CREATE FUNCTION boolop(_int4, query_int) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -COMMENT ON FUNCTION boolop(_int4, query_int) IS 'boolean operation with array'; - -CREATE FUNCTION rboolop(query_int, _int4) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -COMMENT ON FUNCTION rboolop(query_int, _int4) IS 'boolean operation with array'; - -CREATE FUNCTION _int_matchsel(internal, oid, internal, integer) -RETURNS float8 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT STABLE PARALLEL SAFE; - -CREATE OPERATOR @@ ( - LEFTARG = _int4, - RIGHTARG = query_int, - PROCEDURE = boolop, - COMMUTATOR = '~~', - RESTRICT = _int_matchsel, - JOIN = contjoinsel -); - -CREATE OPERATOR ~~ ( - LEFTARG = query_int, - RIGHTARG = _int4, - PROCEDURE = rboolop, - COMMUTATOR = '@@', - RESTRICT = _int_matchsel, - JOIN = contjoinsel -); - - --- --- External C-functions for R-tree methods --- - --- Comparison methods - -CREATE FUNCTION _int_contains(_int4, _int4) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -COMMENT ON FUNCTION _int_contains(_int4, _int4) IS 'contains'; - -CREATE FUNCTION _int_contained(_int4, _int4) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -COMMENT ON FUNCTION _int_contained(_int4, _int4) IS 'contained in'; - -CREATE FUNCTION _int_overlap(_int4, _int4) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -COMMENT ON FUNCTION _int_overlap(_int4, _int4) IS 'overlaps'; - -CREATE FUNCTION _int_same(_int4, _int4) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -COMMENT ON FUNCTION _int_same(_int4, _int4) IS 'same as'; - -CREATE FUNCTION _int_different(_int4, _int4) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different'; - --- support routines for indexing - -CREATE FUNCTION _int_union(_int4, _int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION _int_inter(_int4, _int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION _int_overlap_sel(internal, oid, internal, integer) -RETURNS float8 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT STABLE PARALLEL SAFE; - -CREATE FUNCTION _int_contains_sel(internal, oid, internal, integer) -RETURNS float8 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT STABLE PARALLEL SAFE; - -CREATE FUNCTION _int_contained_sel(internal, oid, internal, integer) -RETURNS float8 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT STABLE PARALLEL SAFE; - -CREATE FUNCTION _int_overlap_joinsel(internal, oid, internal, smallint, internal) -RETURNS float8 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT STABLE PARALLEL SAFE; - -CREATE FUNCTION _int_contains_joinsel(internal, oid, internal, smallint, internal) -RETURNS float8 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT STABLE PARALLEL SAFE; - -CREATE FUNCTION _int_contained_joinsel(internal, oid, internal, smallint, internal) -RETURNS float8 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT STABLE PARALLEL SAFE; - --- --- OPERATORS --- - -CREATE OPERATOR && ( - LEFTARG = _int4, - RIGHTARG = _int4, - PROCEDURE = _int_overlap, - COMMUTATOR = '&&', - RESTRICT = _int_overlap_sel, - JOIN = _int_overlap_joinsel -); - ---CREATE OPERATOR = ( --- LEFTARG = _int4, --- RIGHTARG = _int4, --- PROCEDURE = _int_same, --- COMMUTATOR = '=', --- NEGATOR = '<>', --- RESTRICT = eqsel, --- JOIN = eqjoinsel, --- SORT1 = '<', --- SORT2 = '<' ---); - ---CREATE OPERATOR <> ( --- LEFTARG = _int4, --- RIGHTARG = _int4, --- PROCEDURE = _int_different, --- COMMUTATOR = '<>', --- NEGATOR = '=', --- RESTRICT = neqsel, --- JOIN = neqjoinsel ---); - -CREATE OPERATOR @> ( - LEFTARG = _int4, - RIGHTARG = _int4, - PROCEDURE = _int_contains, - COMMUTATOR = '<@', - RESTRICT = _int_contains_sel, - JOIN = _int_contains_joinsel -); - -CREATE OPERATOR <@ ( - LEFTARG = _int4, - RIGHTARG = _int4, - PROCEDURE = _int_contained, - COMMUTATOR = '@>', - RESTRICT = _int_contained_sel, - JOIN = _int_contained_joinsel -); - --- obsolete: -CREATE OPERATOR @ ( - LEFTARG = _int4, - RIGHTARG = _int4, - PROCEDURE = _int_contains, - COMMUTATOR = '~', - RESTRICT = _int_contains_sel, - JOIN = _int_contains_joinsel -); - -CREATE OPERATOR ~ ( - LEFTARG = _int4, - RIGHTARG = _int4, - PROCEDURE = _int_contained, - COMMUTATOR = '@', - RESTRICT = _int_contained_sel, - JOIN = _int_contained_joinsel -); - --------------- -CREATE FUNCTION intset(int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION icount(_int4) -RETURNS int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE OPERATOR # ( - RIGHTARG = _int4, - PROCEDURE = icount -); - -CREATE FUNCTION sort(_int4, text) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION sort(_int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION sort_asc(_int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION sort_desc(_int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION uniq(_int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION idx(_int4, int4) -RETURNS int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE OPERATOR # ( - LEFTARG = _int4, - RIGHTARG = int4, - PROCEDURE = idx -); - -CREATE FUNCTION subarray(_int4, int4, int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION subarray(_int4, int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION intarray_push_elem(_int4, int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE OPERATOR + ( - LEFTARG = _int4, - RIGHTARG = int4, - PROCEDURE = intarray_push_elem -); - -CREATE FUNCTION intarray_push_array(_int4, _int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE OPERATOR + ( - LEFTARG = _int4, - RIGHTARG = _int4, - COMMUTATOR = +, - PROCEDURE = intarray_push_array -); - -CREATE FUNCTION intarray_del_elem(_int4, int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE OPERATOR - ( - LEFTARG = _int4, - RIGHTARG = int4, - PROCEDURE = intarray_del_elem -); - -CREATE FUNCTION intset_union_elem(_int4, int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE OPERATOR | ( - LEFTARG = _int4, - RIGHTARG = int4, - PROCEDURE = intset_union_elem -); - -CREATE OPERATOR | ( - LEFTARG = _int4, - RIGHTARG = _int4, - COMMUTATOR = |, - PROCEDURE = _int_union -); - -CREATE FUNCTION intset_subtract(_int4, _int4) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE OPERATOR - ( - LEFTARG = _int4, - RIGHTARG = _int4, - PROCEDURE = intset_subtract -); - -CREATE OPERATOR & ( - LEFTARG = _int4, - RIGHTARG = _int4, - COMMUTATOR = &, - PROCEDURE = _int_inter -); --------------- - --- define the GiST support methods -CREATE FUNCTION g_int_consistent(internal,_int4,smallint,oid,internal) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_int_compress(internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_int_decompress(internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_int_penalty(internal,internal,internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_int_picksplit(internal, internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_int_union(internal, internal) -RETURNS _int4 -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_int_same(_int4, _int4, internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - - --- Create the operator class for indexing - -CREATE OPERATOR CLASS gist__int_ops -DEFAULT FOR TYPE _int4 USING gist AS - OPERATOR 3 &&, - OPERATOR 6 = (anyarray, anyarray), - OPERATOR 7 @>, - OPERATOR 8 <@, - OPERATOR 13 @, - OPERATOR 14 ~, - OPERATOR 20 @@ (_int4, query_int), - FUNCTION 1 g_int_consistent (internal, _int4, smallint, oid, internal), - FUNCTION 2 g_int_union (internal, internal), - FUNCTION 3 g_int_compress (internal), - FUNCTION 4 g_int_decompress (internal), - FUNCTION 5 g_int_penalty (internal, internal, internal), - FUNCTION 6 g_int_picksplit (internal, internal), - FUNCTION 7 g_int_same (_int4, _int4, internal); - - ---------------------------------------------- --- intbig ---------------------------------------------- --- define the GiST support methods - -CREATE FUNCTION _intbig_in(cstring) -RETURNS intbig_gkey -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE FUNCTION _intbig_out(intbig_gkey) -RETURNS cstring -AS 'MODULE_PATHNAME' -LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; - -CREATE TYPE intbig_gkey ( - INTERNALLENGTH = -1, - INPUT = _intbig_in, - OUTPUT = _intbig_out -); - -CREATE FUNCTION g_intbig_consistent(internal,_int4,smallint,oid,internal) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_intbig_compress(internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_intbig_decompress(internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_intbig_penalty(internal,internal,internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_intbig_picksplit(internal, internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_intbig_union(internal, internal) -RETURNS intbig_gkey -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION g_intbig_same(intbig_gkey, intbig_gkey, internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - --- register the opclass for indexing (not as default) - -CREATE OPERATOR CLASS gist__intbig_ops -FOR TYPE _int4 USING gist -AS - OPERATOR 3 &&, - OPERATOR 6 = (anyarray, anyarray), - OPERATOR 7 @>, - OPERATOR 8 <@, - OPERATOR 13 @, - OPERATOR 14 ~, - OPERATOR 20 @@ (_int4, query_int), - FUNCTION 1 g_intbig_consistent (internal, _int4, smallint, oid, internal), - FUNCTION 2 g_intbig_union (internal, internal), - FUNCTION 3 g_intbig_compress (internal), - FUNCTION 4 g_intbig_decompress (internal), - FUNCTION 5 g_intbig_penalty (internal, internal, internal), - FUNCTION 6 g_intbig_picksplit (internal, internal), - FUNCTION 7 g_intbig_same (intbig_gkey, intbig_gkey, internal), - STORAGE intbig_gkey; - ---GIN - -CREATE FUNCTION ginint4_queryextract(_int4, internal, int2, internal, internal, internal, internal) -RETURNS internal -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE FUNCTION ginint4_consistent(internal, int2, _int4, int4, internal, internal, internal, internal) -RETURNS bool -AS 'MODULE_PATHNAME' -LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; - -CREATE OPERATOR CLASS gin__int_ops -FOR TYPE _int4 USING gin -AS - OPERATOR 3 &&, - OPERATOR 6 = (anyarray, anyarray), - OPERATOR 7 @>, - OPERATOR 8 <@, - OPERATOR 13 @, - OPERATOR 14 ~, - OPERATOR 20 @@ (_int4, query_int), - FUNCTION 1 btint4cmp (int4, int4), - FUNCTION 2 ginarrayextract (anyarray, internal, internal), - FUNCTION 3 ginint4_queryextract (_int4, internal, int2, internal, internal, internal, internal), - FUNCTION 4 ginint4_consistent (internal, int2, _int4, int4, internal, internal, internal, internal), - STORAGE int4; diff --git a/contrib/intarray/intarray--1.3.sql b/contrib/intarray/intarray--1.3.sql new file mode 100644 index 0000000..6c91c75 --- /dev/null +++ b/contrib/intarray/intarray--1.3.sql @@ -0,0 +1,531 @@ +/* contrib/intarray/intarray--1.2.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION intarray" to load this file. \quit + +-- +-- Create the user-defined type for the 1-D integer arrays (_int4) +-- + +-- Query type +CREATE FUNCTION bqarr_in(cstring) +RETURNS query_int +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION bqarr_out(query_int) +RETURNS cstring +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE TYPE query_int ( + INTERNALLENGTH = -1, + INPUT = bqarr_in, + OUTPUT = bqarr_out +); + +--only for debug +CREATE FUNCTION querytree(query_int) +RETURNS text +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + + +CREATE FUNCTION boolop(_int4, query_int) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +COMMENT ON FUNCTION boolop(_int4, query_int) IS 'boolean operation with array'; + +CREATE FUNCTION rboolop(query_int, _int4) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +COMMENT ON FUNCTION rboolop(query_int, _int4) IS 'boolean operation with array'; + +CREATE FUNCTION _int_matchsel(internal, oid, internal, integer) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT STABLE PARALLEL SAFE; + +CREATE OPERATOR @@ ( + LEFTARG = _int4, + RIGHTARG = query_int, + PROCEDURE = boolop, + COMMUTATOR = '~~', + RESTRICT = _int_matchsel, + JOIN = contjoinsel +); + +CREATE OPERATOR ~~ ( + LEFTARG = query_int, + RIGHTARG = _int4, + PROCEDURE = rboolop, + COMMUTATOR = '@@', + RESTRICT = _int_matchsel, + JOIN = contjoinsel +); + + +-- +-- External C-functions for R-tree methods +-- + +-- Comparison methods + +CREATE FUNCTION _int_contains(_int4, _int4) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +COMMENT ON FUNCTION _int_contains(_int4, _int4) IS 'contains'; + +CREATE FUNCTION _int_contained(_int4, _int4) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +COMMENT ON FUNCTION _int_contained(_int4, _int4) IS 'contained in'; + +CREATE FUNCTION _int_overlap(_int4, _int4) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +COMMENT ON FUNCTION _int_overlap(_int4, _int4) IS 'overlaps'; + +CREATE FUNCTION _int_same(_int4, _int4) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +COMMENT ON FUNCTION _int_same(_int4, _int4) IS 'same as'; + +CREATE FUNCTION _int_different(_int4, _int4) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different'; + +-- support routines for indexing + +CREATE FUNCTION _int_union(_int4, _int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _int_inter(_int4, _int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _int_overlap_sel(internal, oid, internal, integer) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT STABLE PARALLEL SAFE; + +CREATE FUNCTION _int_contains_sel(internal, oid, internal, integer) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT STABLE PARALLEL SAFE; + +CREATE FUNCTION _int_contained_sel(internal, oid, internal, integer) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT STABLE PARALLEL SAFE; + +CREATE FUNCTION _int_overlap_joinsel(internal, oid, internal, smallint, internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT STABLE PARALLEL SAFE; + +CREATE FUNCTION _int_contains_joinsel(internal, oid, internal, smallint, internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT STABLE PARALLEL SAFE; + +CREATE FUNCTION _int_contained_joinsel(internal, oid, internal, smallint, internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT STABLE PARALLEL SAFE; + +-- +-- OPERATORS +-- + +CREATE OPERATOR && ( + LEFTARG = _int4, + RIGHTARG = _int4, + PROCEDURE = _int_overlap, + COMMUTATOR = '&&', + RESTRICT = _int_overlap_sel, + JOIN = _int_overlap_joinsel +); + +--CREATE OPERATOR = ( +-- LEFTARG = _int4, +-- RIGHTARG = _int4, +-- PROCEDURE = _int_same, +-- COMMUTATOR = '=', +-- NEGATOR = '<>', +-- RESTRICT = eqsel, +-- JOIN = eqjoinsel, +-- SORT1 = '<', +-- SORT2 = '<' +--); + +--CREATE OPERATOR <> ( +-- LEFTARG = _int4, +-- RIGHTARG = _int4, +-- PROCEDURE = _int_different, +-- COMMUTATOR = '<>', +-- NEGATOR = '=', +-- RESTRICT = neqsel, +-- JOIN = neqjoinsel +--); + +CREATE OPERATOR @> ( + LEFTARG = _int4, + RIGHTARG = _int4, + PROCEDURE = _int_contains, + COMMUTATOR = '<@', + RESTRICT = _int_contains_sel, + JOIN = _int_contains_joinsel +); + +CREATE OPERATOR <@ ( + LEFTARG = _int4, + RIGHTARG = _int4, + PROCEDURE = _int_contained, + COMMUTATOR = '@>', + RESTRICT = _int_contained_sel, + JOIN = _int_contained_joinsel +); + +-- obsolete: +CREATE OPERATOR @ ( + LEFTARG = _int4, + RIGHTARG = _int4, + PROCEDURE = _int_contains, + COMMUTATOR = '~', + RESTRICT = _int_contains_sel, + JOIN = _int_contains_joinsel +); + +CREATE OPERATOR ~ ( + LEFTARG = _int4, + RIGHTARG = _int4, + PROCEDURE = _int_contained, + COMMUTATOR = '@', + RESTRICT = _int_contained_sel, + JOIN = _int_contained_joinsel +); + +-------------- +CREATE FUNCTION intset(int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION icount(_int4) +RETURNS int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE OPERATOR # ( + RIGHTARG = _int4, + PROCEDURE = icount +); + +CREATE FUNCTION sort(_int4, text) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION sort(_int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION sort_asc(_int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION sort_desc(_int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION uniq(_int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION idx(_int4, int4) +RETURNS int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE OPERATOR # ( + LEFTARG = _int4, + RIGHTARG = int4, + PROCEDURE = idx +); + +CREATE FUNCTION subarray(_int4, int4, int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION subarray(_int4, int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION intarray_push_elem(_int4, int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE OPERATOR + ( + LEFTARG = _int4, + RIGHTARG = int4, + PROCEDURE = intarray_push_elem +); + +CREATE FUNCTION intarray_push_array(_int4, _int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE OPERATOR + ( + LEFTARG = _int4, + RIGHTARG = _int4, + COMMUTATOR = +, + PROCEDURE = intarray_push_array +); + +CREATE FUNCTION intarray_del_elem(_int4, int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE OPERATOR - ( + LEFTARG = _int4, + RIGHTARG = int4, + PROCEDURE = intarray_del_elem +); + +CREATE FUNCTION intset_union_elem(_int4, int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE OPERATOR | ( + LEFTARG = _int4, + RIGHTARG = int4, + PROCEDURE = intset_union_elem +); + +CREATE OPERATOR | ( + LEFTARG = _int4, + RIGHTARG = _int4, + COMMUTATOR = |, + PROCEDURE = _int_union +); + +CREATE FUNCTION intset_subtract(_int4, _int4) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE OPERATOR - ( + LEFTARG = _int4, + RIGHTARG = _int4, + PROCEDURE = intset_subtract +); + +CREATE OPERATOR & ( + LEFTARG = _int4, + RIGHTARG = _int4, + COMMUTATOR = &, + PROCEDURE = _int_inter +); +-------------- + +-- define the GiST support methods +CREATE FUNCTION g_int_consistent(internal,_int4,smallint,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_int_compress(internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_int_decompress(internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_int_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_int_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_int_union(internal, internal) +RETURNS _int4 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_int_same(_int4, _int4, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_int_options(internal, boolean) +RETURNS internal +AS 'MODULE_PATHNAME', 'g_int_options' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- Create the operator class for indexing + +CREATE OPERATOR CLASS gist__int_ops +DEFAULT FOR TYPE _int4 USING gist AS + OPERATOR 3 &&, + OPERATOR 6 = (anyarray, anyarray), + OPERATOR 7 @>, + OPERATOR 8 <@, + OPERATOR 13 @, + OPERATOR 14 ~, + OPERATOR 20 @@ (_int4, query_int), + FUNCTION 1 g_int_consistent (internal, _int4, smallint, oid, internal), + FUNCTION 2 g_int_union (internal, internal), + FUNCTION 3 g_int_compress (internal, internal), + FUNCTION 4 g_int_decompress (internal, internal), + FUNCTION 5 g_int_penalty (internal, internal, internal), + FUNCTION 6 g_int_picksplit (internal, internal), + FUNCTION 7 g_int_same (_int4, _int4, internal), + FUNCTION 10 g_int_options (internal, boolean); + + +--------------------------------------------- +-- intbig +--------------------------------------------- +-- define the GiST support methods + +CREATE FUNCTION _intbig_in(cstring) +RETURNS intbig_gkey +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _intbig_out(intbig_gkey) +RETURNS cstring +AS 'MODULE_PATHNAME' +LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; + +CREATE TYPE intbig_gkey ( + INTERNALLENGTH = -1, + INPUT = _intbig_in, + OUTPUT = _intbig_out +); + +CREATE FUNCTION g_intbig_consistent(internal,_int4,smallint,oid,internal,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_intbig_compress(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_intbig_decompress(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_intbig_penalty(internal,internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_intbig_picksplit(internal, internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_intbig_union(internal, internal, internal) +RETURNS intbig_gkey +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_intbig_same(intbig_gkey, intbig_gkey, internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION g_intbig_options(internal, boolean) +RETURNS internal +AS 'MODULE_PATHNAME', 'g_intbig_options' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- register the opclass for indexing (not as default) + +CREATE OPERATOR CLASS gist__intbig_ops +FOR TYPE _int4 USING gist +AS + OPERATOR 3 &&, + OPERATOR 6 = (anyarray, anyarray), + OPERATOR 7 @>, + OPERATOR 8 <@, + OPERATOR 13 @, + OPERATOR 14 ~, + OPERATOR 20 @@ (_int4, query_int), + FUNCTION 1 g_intbig_consistent (internal, _int4, smallint, oid, internal, internal), + FUNCTION 2 g_intbig_union (internal, internal, internal), + FUNCTION 3 g_intbig_compress (internal, internal), + FUNCTION 4 g_intbig_decompress (internal, internal), + FUNCTION 5 g_intbig_penalty (internal, internal, internal, internal), + FUNCTION 6 g_intbig_picksplit (internal, internal, internal), + FUNCTION 7 g_intbig_same (intbig_gkey, intbig_gkey, internal, internal), + FUNCTION 10 g_intbig_options (internal, boolean), + STORAGE intbig_gkey; + +--GIN + +CREATE FUNCTION ginint4_queryextract(_int4, internal, int2, internal, internal, internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION ginint4_consistent(internal, int2, _int4, int4, internal, internal, internal, internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS gin__int_ops +FOR TYPE _int4 USING gin +AS + OPERATOR 3 &&, + OPERATOR 6 = (anyarray, anyarray), + OPERATOR 7 @>, + OPERATOR 8 <@, + OPERATOR 13 @, + OPERATOR 14 ~, + OPERATOR 20 @@ (_int4, query_int), + FUNCTION 1 btint4cmp (int4, int4), + FUNCTION 2 ginarrayextract (anyarray, internal, internal), + FUNCTION 3 ginint4_queryextract (_int4, internal, int2, internal, internal, internal, internal), + FUNCTION 4 ginint4_consistent (internal, int2, _int4, int4, internal, internal, internal, internal), + STORAGE int4; diff --git a/contrib/intarray/intarray.control b/contrib/intarray/intarray.control index 7e50cc3..72952f7 100644 --- a/contrib/intarray/intarray.control +++ b/contrib/intarray/intarray.control @@ -1,5 +1,5 @@ # intarray extension comment = 'functions, operators, and index support for 1-D arrays of integers' -default_version = '1.2' +default_version = '1.3' module_pathname = '$libdir/_int' relocatable = true diff --git a/doc/src/sgml/intarray.sgml b/doc/src/sgml/intarray.sgml index b633cf3..2540cc6 100644 --- a/doc/src/sgml/intarray.sgml +++ b/doc/src/sgml/intarray.sgml @@ -259,14 +259,22 @@ - Two GiST index operator classes are provided: - gist__int_ops (used by default) is suitable for + Two parametrized GiST index operator classes are provided: + gist__int_ops(numranges) (used by default) is suitable for small- to medium-size data sets, while - gist__intbig_ops uses a larger signature and is more + gist__intbig_ops(siglen) uses a larger signature and is more suitable for indexing large data sets (i.e., columns containing a large number of distinct array values). The implementation uses an RD-tree data structure with built-in lossy compression. + + Optional integer parameter numranges of + gist__int_ops determines + number of ranges in compressed array (100 by default). + + Optional integer parameter siglen of + gist__intbig_ops determines + signature length in bytes (252 by default, 488 maximum).