diff options
Diffstat (limited to 'contrib/btree_gist')
120 files changed, 24563 insertions, 0 deletions
diff --git a/contrib/btree_gist/.gitignore b/contrib/btree_gist/.gitignore new file mode 100644 index 0000000..5dcb3ff --- /dev/null +++ b/contrib/btree_gist/.gitignore @@ -0,0 +1,4 @@ +# Generated subdirectories +/log/ +/results/ +/tmp_check/ diff --git a/contrib/btree_gist/Makefile b/contrib/btree_gist/Makefile new file mode 100644 index 0000000..48997c7 --- /dev/null +++ b/contrib/btree_gist/Makefile @@ -0,0 +1,54 @@ +# contrib/btree_gist/Makefile + +MODULE_big = btree_gist + +OBJS = \ + $(WIN32RES) \ + btree_bit.o \ + btree_bool.o \ + btree_bytea.o \ + btree_cash.o \ + btree_date.o \ + btree_enum.o \ + btree_float4.o \ + btree_float8.o \ + btree_gist.o \ + btree_inet.o \ + btree_int2.o \ + btree_int4.o \ + btree_int8.o \ + btree_interval.o \ + btree_macaddr.o \ + btree_macaddr8.o \ + btree_numeric.o \ + btree_oid.o \ + btree_text.o \ + btree_time.o \ + btree_ts.o \ + btree_utils_num.o \ + btree_utils_var.o \ + btree_uuid.o + +EXTENSION = btree_gist +DATA = btree_gist--1.0--1.1.sql \ + btree_gist--1.1--1.2.sql btree_gist--1.2.sql btree_gist--1.2--1.3.sql \ + btree_gist--1.3--1.4.sql btree_gist--1.4--1.5.sql \ + btree_gist--1.5--1.6.sql btree_gist--1.6--1.7.sql +PGFILEDESC = "btree_gist - B-tree equivalent GiST operator classes" + +REGRESS = init int2 int4 int8 float4 float8 cash oid timestamp timestamptz \ + time timetz date interval macaddr macaddr8 inet cidr text varchar char \ + bytea bit varbit numeric uuid not_equal enum bool + +SHLIB_LINK += $(filter -lm, $(LIBS)) + +ifdef USE_PGXS +PG_CONFIG = pg_config +PGXS := $(shell $(PG_CONFIG) --pgxs) +include $(PGXS) +else +subdir = contrib/btree_gist +top_builddir = ../.. +include $(top_builddir)/src/Makefile.global +include $(top_srcdir)/contrib/contrib-global.mk +endif diff --git a/contrib/btree_gist/btree_bit.c b/contrib/btree_gist/btree_bit.c new file mode 100644 index 0000000..5b246bc --- /dev/null +++ b/contrib/btree_gist/btree_bit.c @@ -0,0 +1,210 @@ +/* + * contrib/btree_gist/btree_bit.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_var.h" +#include "utils/builtins.h" +#include "utils/bytea.h" +#include "utils/varbit.h" + + +/* +** Bit ops +*/ +PG_FUNCTION_INFO_V1(gbt_bit_compress); +PG_FUNCTION_INFO_V1(gbt_bit_union); +PG_FUNCTION_INFO_V1(gbt_bit_picksplit); +PG_FUNCTION_INFO_V1(gbt_bit_consistent); +PG_FUNCTION_INFO_V1(gbt_bit_penalty); +PG_FUNCTION_INFO_V1(gbt_bit_same); + + +/* define for comparison */ + +static bool +gbt_bitgt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(bitgt, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bitge(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(bitge, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_biteq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(biteq, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bitle(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(bitle, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bitlt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(bitlt, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static int32 +gbt_bitcmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetInt32(DirectFunctionCall2(byteacmp, + PointerGetDatum(a), + PointerGetDatum(b))); +} + + +static bytea * +gbt_bit_xfrm(bytea *leaf) +{ + bytea *out = leaf; + int sz = VARBITBYTES(leaf) + VARHDRSZ; + int padded_sz = INTALIGN(sz); + + out = (bytea *) palloc(padded_sz); + /* initialize the padding bytes to zero */ + while (sz < padded_sz) + ((char *) out)[sz++] = 0; + SET_VARSIZE(out, padded_sz); + memcpy((void *) VARDATA(out), (void *) VARBITS(leaf), VARBITBYTES(leaf)); + return out; +} + + + + +static GBT_VARKEY * +gbt_bit_l2n(GBT_VARKEY *leaf, FmgrInfo *flinfo) +{ + GBT_VARKEY *out = leaf; + GBT_VARKEY_R r = gbt_var_key_readable(leaf); + bytea *o; + + o = gbt_bit_xfrm(r.lower); + r.upper = r.lower = o; + out = gbt_var_key_copy(&r); + pfree(o); + + return out; +} + +static const gbtree_vinfo tinfo = +{ + gbt_t_bit, + 0, + true, + gbt_bitgt, + gbt_bitge, + gbt_biteq, + gbt_bitle, + gbt_bitlt, + gbt_bitcmp, + gbt_bit_l2n +}; + + +/************************************************** + * Bit ops + **************************************************/ + +Datum +gbt_bit_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); +} + +Datum +gbt_bit_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + bool retval; + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY_R r = gbt_var_key_readable(key); + + /* All cases served by this function are exact */ + *recheck = false; + + if (GIST_LEAF(entry)) + retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(), + true, &tinfo, fcinfo->flinfo); + else + { + bytea *q = gbt_bit_xfrm((bytea *) query); + + retval = gbt_var_consistent(&r, q, strategy, PG_GET_COLLATION(), + false, &tinfo, fcinfo->flinfo); + } + PG_RETURN_BOOL(retval); +} + + + +Datum +gbt_bit_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_bit_picksplit(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + + gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(v); +} + +Datum +gbt_bit_same(PG_FUNCTION_ARGS) +{ + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} + + +Datum +gbt_bit_penalty(PG_FUNCTION_ARGS) +{ + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); + + PG_RETURN_POINTER(gbt_var_penalty(result, o, n, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo)); +} diff --git a/contrib/btree_gist/btree_bool.c b/contrib/btree_gist/btree_bool.c new file mode 100644 index 0000000..8b2af12 --- /dev/null +++ b/contrib/btree_gist/btree_bool.c @@ -0,0 +1,169 @@ +/* + * contrib/btree_gist/btree_bool.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "common/int.h" + +typedef struct boolkey +{ + bool lower; + bool upper; +} boolKEY; + +/* +** bool ops +*/ +PG_FUNCTION_INFO_V1(gbt_bool_compress); +PG_FUNCTION_INFO_V1(gbt_bool_fetch); +PG_FUNCTION_INFO_V1(gbt_bool_union); +PG_FUNCTION_INFO_V1(gbt_bool_picksplit); +PG_FUNCTION_INFO_V1(gbt_bool_consistent); +PG_FUNCTION_INFO_V1(gbt_bool_penalty); +PG_FUNCTION_INFO_V1(gbt_bool_same); + +static bool +gbt_boolgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const bool *) a) > *((const bool *) b)); +} +static bool +gbt_boolge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const bool *) a) >= *((const bool *) b)); +} +static bool +gbt_booleq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const bool *) a) == *((const bool *) b)); +} +static bool +gbt_boolle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const bool *) a) <= *((const bool *) b)); +} +static bool +gbt_boollt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const bool *) a) < *((const bool *) b)); +} + +static int +gbt_boolkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + boolKEY *ia = (boolKEY *) (((const Nsrt *) a)->t); + boolKEY *ib = (boolKEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_bool, + sizeof(bool), + 2, /* sizeof(gbtreekey2) */ + gbt_boolgt, + gbt_boolge, + gbt_booleq, + gbt_boolle, + gbt_boollt, + gbt_boolkey_cmp, +}; + + +/************************************************** + * bool ops + **************************************************/ + + +Datum +gbt_bool_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_bool_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_bool_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + bool query = PG_GETARG_INT16(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + boolKEY *kkk = (boolKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_bool_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(boolKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(boolKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_bool_penalty(PG_FUNCTION_ARGS) +{ + boolKEY *origentry = (boolKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + boolKEY *newentry = (boolKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_bool_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_bool_same(PG_FUNCTION_ARGS) +{ + boolKEY *b1 = (boolKEY *) PG_GETARG_POINTER(0); + boolKEY *b2 = (boolKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_bytea.c b/contrib/btree_gist/btree_bytea.c new file mode 100644 index 0000000..6b005f0 --- /dev/null +++ b/contrib/btree_gist/btree_bytea.c @@ -0,0 +1,170 @@ +/* + * contrib/btree_gist/btree_bytea.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_var.h" +#include "utils/builtins.h" +#include "utils/bytea.h" + + +/* +** Bytea ops +*/ +PG_FUNCTION_INFO_V1(gbt_bytea_compress); +PG_FUNCTION_INFO_V1(gbt_bytea_union); +PG_FUNCTION_INFO_V1(gbt_bytea_picksplit); +PG_FUNCTION_INFO_V1(gbt_bytea_consistent); +PG_FUNCTION_INFO_V1(gbt_bytea_penalty); +PG_FUNCTION_INFO_V1(gbt_bytea_same); + + +/* define for comparison */ + +static bool +gbt_byteagt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(byteagt, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_byteage(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(byteage, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_byteaeq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(byteaeq, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_byteale(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(byteale, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bytealt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(bytealt, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static int32 +gbt_byteacmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetInt32(DirectFunctionCall2(byteacmp, + PointerGetDatum(a), + PointerGetDatum(b))); +} + + +static const gbtree_vinfo tinfo = +{ + gbt_t_bytea, + 0, + true, + gbt_byteagt, + gbt_byteage, + gbt_byteaeq, + gbt_byteale, + gbt_bytealt, + gbt_byteacmp, + NULL +}; + + +/************************************************** + * Text ops + **************************************************/ + + +Datum +gbt_bytea_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); +} + + + +Datum +gbt_bytea_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + bool retval; + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY_R r = gbt_var_key_readable(key); + + /* All cases served by this function are exact */ + *recheck = false; + + retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(), + GIST_LEAF(entry), &tinfo, fcinfo->flinfo); + PG_RETURN_BOOL(retval); +} + + + +Datum +gbt_bytea_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_bytea_picksplit(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + + gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(v); +} + +Datum +gbt_bytea_same(PG_FUNCTION_ARGS) +{ + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} + + +Datum +gbt_bytea_penalty(PG_FUNCTION_ARGS) +{ + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); + + PG_RETURN_POINTER(gbt_var_penalty(result, o, n, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo)); +} diff --git a/contrib/btree_gist/btree_cash.c b/contrib/btree_gist/btree_cash.c new file mode 100644 index 0000000..6ac97e2 --- /dev/null +++ b/contrib/btree_gist/btree_cash.c @@ -0,0 +1,217 @@ +/* + * contrib/btree_gist/btree_cash.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "common/int.h" +#include "utils/cash.h" + +typedef struct +{ + Cash lower; + Cash upper; +} cashKEY; + +/* +** Cash ops +*/ +PG_FUNCTION_INFO_V1(gbt_cash_compress); +PG_FUNCTION_INFO_V1(gbt_cash_fetch); +PG_FUNCTION_INFO_V1(gbt_cash_union); +PG_FUNCTION_INFO_V1(gbt_cash_picksplit); +PG_FUNCTION_INFO_V1(gbt_cash_consistent); +PG_FUNCTION_INFO_V1(gbt_cash_distance); +PG_FUNCTION_INFO_V1(gbt_cash_penalty); +PG_FUNCTION_INFO_V1(gbt_cash_same); + +static bool +gbt_cashgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Cash *) a) > *((const Cash *) b)); +} +static bool +gbt_cashge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Cash *) a) >= *((const Cash *) b)); +} +static bool +gbt_casheq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Cash *) a) == *((const Cash *) b)); +} +static bool +gbt_cashle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Cash *) a) <= *((const Cash *) b)); +} +static bool +gbt_cashlt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Cash *) a) < *((const Cash *) b)); +} + +static int +gbt_cashkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + cashKEY *ia = (cashKEY *) (((const Nsrt *) a)->t); + cashKEY *ib = (cashKEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + +static float8 +gbt_cash_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + return GET_FLOAT_DISTANCE(Cash, a, b); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_cash, + sizeof(Cash), + 16, /* sizeof(gbtreekey16) */ + gbt_cashgt, + gbt_cashge, + gbt_casheq, + gbt_cashle, + gbt_cashlt, + gbt_cashkey_cmp, + gbt_cash_dist +}; + + +PG_FUNCTION_INFO_V1(cash_dist); +Datum +cash_dist(PG_FUNCTION_ARGS) +{ + Cash a = PG_GETARG_CASH(0); + Cash b = PG_GETARG_CASH(1); + Cash r; + Cash ra; + + if (pg_sub_s64_overflow(a, b, &r) || + r == PG_INT64_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("money out of range"))); + + ra = Abs(r); + + PG_RETURN_CASH(ra); +} + +/************************************************** + * Cash ops + **************************************************/ + + +Datum +gbt_cash_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_cash_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_cash_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Cash query = PG_GETARG_CASH(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + cashKEY *kkk = (cashKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, + fcinfo->flinfo)); +} + + +Datum +gbt_cash_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Cash query = PG_GETARG_CASH(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + cashKEY *kkk = (cashKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_cash_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(cashKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(cashKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_cash_penalty(PG_FUNCTION_ARGS) +{ + cashKEY *origentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + cashKEY *newentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_cash_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_cash_same(PG_FUNCTION_ARGS) +{ + cashKEY *b1 = (cashKEY *) PG_GETARG_POINTER(0); + cashKEY *b2 = (cashKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_date.c b/contrib/btree_gist/btree_date.c new file mode 100644 index 0000000..455a265 --- /dev/null +++ b/contrib/btree_gist/btree_date.c @@ -0,0 +1,259 @@ +/* + * contrib/btree_gist/btree_date.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/builtins.h" +#include "utils/date.h" + +typedef struct +{ + DateADT lower; + DateADT upper; +} dateKEY; + +/* +** date ops +*/ +PG_FUNCTION_INFO_V1(gbt_date_compress); +PG_FUNCTION_INFO_V1(gbt_date_fetch); +PG_FUNCTION_INFO_V1(gbt_date_union); +PG_FUNCTION_INFO_V1(gbt_date_picksplit); +PG_FUNCTION_INFO_V1(gbt_date_consistent); +PG_FUNCTION_INFO_V1(gbt_date_distance); +PG_FUNCTION_INFO_V1(gbt_date_penalty); +PG_FUNCTION_INFO_V1(gbt_date_same); + +static bool +gbt_dategt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(date_gt, + DateADTGetDatum(*((const DateADT *) a)), + DateADTGetDatum(*((const DateADT *) b)))); +} + +static bool +gbt_datege(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(date_ge, + DateADTGetDatum(*((const DateADT *) a)), + DateADTGetDatum(*((const DateADT *) b)))); +} + +static bool +gbt_dateeq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(date_eq, + DateADTGetDatum(*((const DateADT *) a)), + DateADTGetDatum(*((const DateADT *) b))) + ); +} + +static bool +gbt_datele(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(date_le, + DateADTGetDatum(*((const DateADT *) a)), + DateADTGetDatum(*((const DateADT *) b)))); +} + +static bool +gbt_datelt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(date_lt, + DateADTGetDatum(*((const DateADT *) a)), + DateADTGetDatum(*((const DateADT *) b)))); +} + + + +static int +gbt_datekey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + dateKEY *ia = (dateKEY *) (((const Nsrt *) a)->t); + dateKEY *ib = (dateKEY *) (((const Nsrt *) b)->t); + int res; + + res = DatumGetInt32(DirectFunctionCall2(date_cmp, + DateADTGetDatum(ia->lower), + DateADTGetDatum(ib->lower))); + if (res == 0) + return DatumGetInt32(DirectFunctionCall2(date_cmp, + DateADTGetDatum(ia->upper), + DateADTGetDatum(ib->upper))); + + return res; +} + +static float8 +gdb_date_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + /* we assume the difference can't overflow */ + Datum diff = DirectFunctionCall2(date_mi, + DateADTGetDatum(*((const DateADT *) a)), + DateADTGetDatum(*((const DateADT *) b))); + + return (float8) Abs(DatumGetInt32(diff)); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_date, + sizeof(DateADT), + 8, /* sizeof(gbtreekey8) */ + gbt_dategt, + gbt_datege, + gbt_dateeq, + gbt_datele, + gbt_datelt, + gbt_datekey_cmp, + gdb_date_dist +}; + + +PG_FUNCTION_INFO_V1(date_dist); +Datum +date_dist(PG_FUNCTION_ARGS) +{ + /* we assume the difference can't overflow */ + Datum diff = DirectFunctionCall2(date_mi, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1)); + + PG_RETURN_INT32(Abs(DatumGetInt32(diff))); +} + + +/************************************************** + * date ops + **************************************************/ + + + +Datum +gbt_date_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_date_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_date_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + DateADT query = PG_GETARG_DATEADT(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + dateKEY *kkk = (dateKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, + fcinfo->flinfo)); +} + + +Datum +gbt_date_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + DateADT query = PG_GETARG_DATEADT(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + dateKEY *kkk = (dateKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_date_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(dateKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(dateKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_date_penalty(PG_FUNCTION_ARGS) +{ + dateKEY *origentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + dateKEY *newentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + int32 diff, + res; + + diff = DatumGetInt32(DirectFunctionCall2(date_mi, + DateADTGetDatum(newentry->upper), + DateADTGetDatum(origentry->upper))); + + res = Max(diff, 0); + + diff = DatumGetInt32(DirectFunctionCall2(date_mi, + DateADTGetDatum(origentry->lower), + DateADTGetDatum(newentry->lower))); + + res += Max(diff, 0); + + *result = 0.0; + + if (res > 0) + { + diff = DatumGetInt32(DirectFunctionCall2(date_mi, + DateADTGetDatum(origentry->upper), + DateADTGetDatum(origentry->lower))); + *result += FLT_MIN; + *result += (float) (res / ((double) (res + diff))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } + + PG_RETURN_POINTER(result); +} + + +Datum +gbt_date_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_date_same(PG_FUNCTION_ARGS) +{ + dateKEY *b1 = (dateKEY *) PG_GETARG_POINTER(0); + dateKEY *b2 = (dateKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_enum.c b/contrib/btree_gist/btree_enum.c new file mode 100644 index 0000000..d4dc38a --- /dev/null +++ b/contrib/btree_gist/btree_enum.c @@ -0,0 +1,185 @@ +/* + * contrib/btree_gist/btree_enum.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "fmgr.h" +#include "utils/builtins.h" + +/* enums are really Oids, so we just use the same structure */ + +typedef struct +{ + Oid lower; + Oid upper; +} oidKEY; + +/* +** enum ops +*/ +PG_FUNCTION_INFO_V1(gbt_enum_compress); +PG_FUNCTION_INFO_V1(gbt_enum_fetch); +PG_FUNCTION_INFO_V1(gbt_enum_union); +PG_FUNCTION_INFO_V1(gbt_enum_picksplit); +PG_FUNCTION_INFO_V1(gbt_enum_consistent); +PG_FUNCTION_INFO_V1(gbt_enum_penalty); +PG_FUNCTION_INFO_V1(gbt_enum_same); + + +static bool +gbt_enumgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(CallerFInfoFunctionCall2(enum_gt, flinfo, InvalidOid, + ObjectIdGetDatum(*((const Oid *) a)), + ObjectIdGetDatum(*((const Oid *) b)))); +} +static bool +gbt_enumge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(CallerFInfoFunctionCall2(enum_ge, flinfo, InvalidOid, + ObjectIdGetDatum(*((const Oid *) a)), + ObjectIdGetDatum(*((const Oid *) b)))); +} +static bool +gbt_enumeq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Oid *) a) == *((const Oid *) b)); +} +static bool +gbt_enumle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(CallerFInfoFunctionCall2(enum_le, flinfo, InvalidOid, + ObjectIdGetDatum(*((const Oid *) a)), + ObjectIdGetDatum(*((const Oid *) b)))); +} +static bool +gbt_enumlt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(CallerFInfoFunctionCall2(enum_lt, flinfo, InvalidOid, + ObjectIdGetDatum(*((const Oid *) a)), + ObjectIdGetDatum(*((const Oid *) b)))); +} + +static int +gbt_enumkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + oidKEY *ia = (oidKEY *) (((const Nsrt *) a)->t); + oidKEY *ib = (oidKEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return DatumGetInt32(CallerFInfoFunctionCall2(enum_cmp, flinfo, InvalidOid, + ObjectIdGetDatum(ia->upper), + ObjectIdGetDatum(ib->upper))); + } + + return DatumGetInt32(CallerFInfoFunctionCall2(enum_cmp, flinfo, InvalidOid, + ObjectIdGetDatum(ia->lower), + ObjectIdGetDatum(ib->lower))); +} + +static const gbtree_ninfo tinfo = +{ + gbt_t_enum, + sizeof(Oid), + 8, /* sizeof(gbtreekey8) */ + gbt_enumgt, + gbt_enumge, + gbt_enumeq, + gbt_enumle, + gbt_enumlt, + gbt_enumkey_cmp, + NULL /* no KNN support at least for now */ +}; + + +/************************************************** + * Enum ops + **************************************************/ + + +Datum +gbt_enum_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_enum_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_enum_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Oid query = PG_GETARG_OID(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + oidKEY *kkk = (oidKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, + fcinfo->flinfo)); +} + +Datum +gbt_enum_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(oidKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(oidKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_enum_penalty(PG_FUNCTION_ARGS) +{ + oidKEY *origentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + oidKEY *newentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_enum_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_enum_same(PG_FUNCTION_ARGS) +{ + oidKEY *b1 = (oidKEY *) PG_GETARG_POINTER(0); + oidKEY *b2 = (oidKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_float4.c b/contrib/btree_gist/btree_float4.c new file mode 100644 index 0000000..3cbd9a0 --- /dev/null +++ b/contrib/btree_gist/btree_float4.c @@ -0,0 +1,212 @@ +/* + * contrib/btree_gist/btree_float4.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/float.h" + +typedef struct float4key +{ + float4 lower; + float4 upper; +} float4KEY; + +/* +** float4 ops +*/ +PG_FUNCTION_INFO_V1(gbt_float4_compress); +PG_FUNCTION_INFO_V1(gbt_float4_fetch); +PG_FUNCTION_INFO_V1(gbt_float4_union); +PG_FUNCTION_INFO_V1(gbt_float4_picksplit); +PG_FUNCTION_INFO_V1(gbt_float4_consistent); +PG_FUNCTION_INFO_V1(gbt_float4_distance); +PG_FUNCTION_INFO_V1(gbt_float4_penalty); +PG_FUNCTION_INFO_V1(gbt_float4_same); + +static bool +gbt_float4gt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float4 *) a) > *((const float4 *) b)); +} +static bool +gbt_float4ge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float4 *) a) >= *((const float4 *) b)); +} +static bool +gbt_float4eq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float4 *) a) == *((const float4 *) b)); +} +static bool +gbt_float4le(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float4 *) a) <= *((const float4 *) b)); +} +static bool +gbt_float4lt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float4 *) a) < *((const float4 *) b)); +} + +static int +gbt_float4key_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + float4KEY *ia = (float4KEY *) (((const Nsrt *) a)->t); + float4KEY *ib = (float4KEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + +static float8 +gbt_float4_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + return GET_FLOAT_DISTANCE(float4, a, b); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_float4, + sizeof(float4), + 8, /* sizeof(gbtreekey8) */ + gbt_float4gt, + gbt_float4ge, + gbt_float4eq, + gbt_float4le, + gbt_float4lt, + gbt_float4key_cmp, + gbt_float4_dist +}; + + +PG_FUNCTION_INFO_V1(float4_dist); +Datum +float4_dist(PG_FUNCTION_ARGS) +{ + float4 a = PG_GETARG_FLOAT4(0); + float4 b = PG_GETARG_FLOAT4(1); + float4 r; + + r = a - b; + if (unlikely(isinf(r)) && !isinf(a) && !isinf(b)) + float_overflow_error(); + + PG_RETURN_FLOAT4(Abs(r)); +} + + +/************************************************** + * float4 ops + **************************************************/ + + +Datum +gbt_float4_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_float4_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_float4_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + float4 query = PG_GETARG_FLOAT4(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + float4KEY *kkk = (float4KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, + fcinfo->flinfo)); +} + + +Datum +gbt_float4_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + float4 query = PG_GETARG_FLOAT4(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + float4KEY *kkk = (float4KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_float4_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(float4KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(float4KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_float4_penalty(PG_FUNCTION_ARGS) +{ + float4KEY *origentry = (float4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + float4KEY *newentry = (float4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_float4_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_float4_same(PG_FUNCTION_ARGS) +{ + float4KEY *b1 = (float4KEY *) PG_GETARG_POINTER(0); + float4KEY *b2 = (float4KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_float8.c b/contrib/btree_gist/btree_float8.c new file mode 100644 index 0000000..b95a08e --- /dev/null +++ b/contrib/btree_gist/btree_float8.c @@ -0,0 +1,219 @@ +/* + * contrib/btree_gist/btree_float8.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/float.h" + +typedef struct float8key +{ + float8 lower; + float8 upper; +} float8KEY; + +/* +** float8 ops +*/ +PG_FUNCTION_INFO_V1(gbt_float8_compress); +PG_FUNCTION_INFO_V1(gbt_float8_fetch); +PG_FUNCTION_INFO_V1(gbt_float8_union); +PG_FUNCTION_INFO_V1(gbt_float8_picksplit); +PG_FUNCTION_INFO_V1(gbt_float8_consistent); +PG_FUNCTION_INFO_V1(gbt_float8_distance); +PG_FUNCTION_INFO_V1(gbt_float8_penalty); +PG_FUNCTION_INFO_V1(gbt_float8_same); + + +static bool +gbt_float8gt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float8 *) a) > *((const float8 *) b)); +} +static bool +gbt_float8ge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float8 *) a) >= *((const float8 *) b)); +} +static bool +gbt_float8eq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float8 *) a) == *((const float8 *) b)); +} +static bool +gbt_float8le(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float8 *) a) <= *((const float8 *) b)); +} +static bool +gbt_float8lt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const float8 *) a) < *((const float8 *) b)); +} + +static int +gbt_float8key_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + float8KEY *ia = (float8KEY *) (((const Nsrt *) a)->t); + float8KEY *ib = (float8KEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + +static float8 +gbt_float8_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + float8 arg1 = *(const float8 *) a; + float8 arg2 = *(const float8 *) b; + float8 r; + + r = arg1 - arg2; + if (unlikely(isinf(r)) && !isinf(arg1) && !isinf(arg2)) + float_overflow_error(); + return Abs(r); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_float8, + sizeof(float8), + 16, /* sizeof(gbtreekey16) */ + gbt_float8gt, + gbt_float8ge, + gbt_float8eq, + gbt_float8le, + gbt_float8lt, + gbt_float8key_cmp, + gbt_float8_dist +}; + + +PG_FUNCTION_INFO_V1(float8_dist); +Datum +float8_dist(PG_FUNCTION_ARGS) +{ + float8 a = PG_GETARG_FLOAT8(0); + float8 b = PG_GETARG_FLOAT8(1); + float8 r; + + r = a - b; + if (unlikely(isinf(r)) && !isinf(a) && !isinf(b)) + float_overflow_error(); + + PG_RETURN_FLOAT8(Abs(r)); +} + +/************************************************** + * float8 ops + **************************************************/ + + +Datum +gbt_float8_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_float8_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_float8_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + float8 query = PG_GETARG_FLOAT8(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + float8KEY *kkk = (float8KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, + fcinfo->flinfo)); +} + + +Datum +gbt_float8_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + float8 query = PG_GETARG_FLOAT8(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + float8KEY *kkk = (float8KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_float8_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(float8KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(float8KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_float8_penalty(PG_FUNCTION_ARGS) +{ + float8KEY *origentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + float8KEY *newentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_float8_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_float8_same(PG_FUNCTION_ARGS) +{ + float8KEY *b1 = (float8KEY *) PG_GETARG_POINTER(0); + float8KEY *b2 = (float8KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_gist--1.0--1.1.sql b/contrib/btree_gist/btree_gist--1.0--1.1.sql new file mode 100644 index 0000000..2633bea --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.0--1.1.sql @@ -0,0 +1,127 @@ +/* contrib/btree_gist/btree_gist--1.0--1.1.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.1'" to load this file. \quit + +-- Index-only scan support new in 9.5. +CREATE FUNCTION gbt_oid_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_var_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY gist_oid_ops USING gist ADD + FUNCTION 9 (oid, oid) gbt_oid_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_int2_ops USING gist ADD + FUNCTION 9 (int2, int2) gbt_int2_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_int4_ops USING gist ADD + FUNCTION 9 (int4, int4) gbt_int4_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_int8_ops USING gist ADD + FUNCTION 9 (int8, int8) gbt_int8_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_float4_ops USING gist ADD + FUNCTION 9 (float4, float4) gbt_float4_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_float8_ops USING gist ADD + FUNCTION 9 (float8, float8) gbt_float8_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_timestamp_ops USING gist ADD + FUNCTION 9 (timestamp, timestamp) gbt_ts_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_timestamptz_ops USING gist ADD + FUNCTION 9 (timestamptz, timestamptz) gbt_ts_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_time_ops USING gist ADD + FUNCTION 9 (time, time) gbt_time_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_date_ops USING gist ADD + FUNCTION 9 (date, date) gbt_date_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_interval_ops USING gist ADD + FUNCTION 9 (interval, interval) gbt_intv_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_cash_ops USING gist ADD + FUNCTION 9 (money, money) gbt_cash_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_macaddr_ops USING gist ADD + FUNCTION 9 (macaddr, macaddr) gbt_macad_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_text_ops USING gist ADD + FUNCTION 9 (text, text) gbt_var_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_bpchar_ops USING gist ADD + FUNCTION 9 (bpchar, bpchar) gbt_var_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_bytea_ops USING gist ADD + FUNCTION 9 (bytea, bytea) gbt_var_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_numeric_ops USING gist ADD + FUNCTION 9 (numeric, numeric) gbt_var_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_bit_ops USING gist ADD + FUNCTION 9 (bit, bit) gbt_var_fetch (internal) ; + +ALTER OPERATOR FAMILY gist_vbit_ops USING gist ADD + FUNCTION 9 (varbit, varbit) gbt_var_fetch (internal) ; diff --git a/contrib/btree_gist/btree_gist--1.1--1.2.sql b/contrib/btree_gist/btree_gist--1.1--1.2.sql new file mode 100644 index 0000000..d5a8c6c --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.1--1.2.sql @@ -0,0 +1,79 @@ +/* contrib/btree_gist/btree_gist--1.1--1.2.sql */ + +-- complain if script is sourced in psql, rather than via ALTER EXTENSION +\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.2'" 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. + +DO LANGUAGE plpgsql +$$ +DECLARE + my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema()); + old_path pg_catalog.text := pg_catalog.current_setting('search_path'); +BEGIN +-- for safety, transiently set search_path to just pg_catalog+pg_temp +PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true); + +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.text[]), -- establish column types +('gbt_oid_distance(internal,oid,int2,oid)', '{internal,oid,int2,oid,internal}'), +('gbt_oid_union(bytea,internal)', '{internal,internal}'), +('gbt_oid_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'), +('gbt_int2_distance(internal,int2,int2,oid)', '{internal,int2,int2,oid,internal}'), +('gbt_int2_union(bytea,internal)', '{internal,internal}'), +('gbt_int2_same(internal,internal,internal)', '{SCH.gbtreekey4,SCH.gbtreekey4,internal}'), +('gbt_int4_distance(internal,int4,int2,oid)', '{internal,int4,int2,oid,internal}'), +('gbt_int4_union(bytea,internal)', '{internal,internal}'), +('gbt_int4_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'), +('gbt_int8_distance(internal,int8,int2,oid)', '{internal,int8,int2,oid,internal}'), +('gbt_int8_union(bytea,internal)', '{internal,internal}'), +('gbt_int8_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'), +('gbt_float4_distance(internal,float4,int2,oid)', '{internal,float4,int2,oid,internal}'), +('gbt_float4_union(bytea,internal)', '{internal,internal}'), +('gbt_float4_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'), +('gbt_float8_distance(internal,float8,int2,oid)', '{internal,float8,int2,oid,internal}'), +('gbt_float8_union(bytea,internal)', '{internal,internal}'), +('gbt_float8_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'), +('gbt_ts_distance(internal,timestamp,int2,oid)', '{internal,timestamp,int2,oid,internal}'), +('gbt_tstz_distance(internal,timestamptz,int2,oid)', '{internal,timestamptz,int2,oid,internal}'), +('gbt_ts_union(bytea,internal)', '{internal,internal}'), +('gbt_ts_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'), +('gbt_time_distance(internal,time,int2,oid)', '{internal,time,int2,oid,internal}'), +('gbt_time_union(bytea,internal)', '{internal,internal}'), +('gbt_time_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'), +('gbt_date_distance(internal,date,int2,oid)', '{internal,date,int2,oid,internal}'), +('gbt_date_union(bytea,internal)', '{internal,internal}'), +('gbt_date_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'), +('gbt_intv_distance(internal,interval,int2,oid)', '{internal,interval,int2,oid,internal}'), +('gbt_intv_union(bytea,internal)', '{internal,internal}'), +('gbt_intv_same(internal,internal,internal)', '{SCH.gbtreekey32,SCH.gbtreekey32,internal}'), +('gbt_cash_distance(internal,money,int2,oid)', '{internal,money,int2,oid,internal}'), +('gbt_cash_union(bytea,internal)', '{internal,internal}'), +('gbt_cash_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'), +('gbt_macad_union(bytea,internal)', '{internal,internal}'), +('gbt_macad_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'), +('gbt_text_union(bytea,internal)', '{internal,internal}'), +('gbt_text_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'), +('gbt_bytea_union(bytea,internal)', '{internal,internal}'), +('gbt_bytea_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'), +('gbt_numeric_union(bytea,internal)', '{internal,internal}'), +('gbt_numeric_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'), +('gbt_bit_union(bytea,internal)', '{internal,internal}'), +('gbt_bit_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'), +('gbt_inet_union(bytea,internal)', '{internal,internal}'), +('gbt_inet_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}') +) AS update_data (oldproc, newtypestext), +LATERAL ( + SELECT array_agg(replace(typ, 'SCH', my_schema)::regtype) as newtypes FROM unnest(newtypestext) typ +) ls +WHERE oid = to_regprocedure(my_schema || '.' || replace(oldproc, 'SCH', my_schema)); + +PERFORM pg_catalog.set_config('search_path', old_path, true); +END +$$; diff --git a/contrib/btree_gist/btree_gist--1.2--1.3.sql b/contrib/btree_gist/btree_gist--1.2--1.3.sql new file mode 100644 index 0000000..726561e --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.2--1.3.sql @@ -0,0 +1,65 @@ +/* contrib/btree_gist/btree_gist--1.2--1.3.sql */ + +-- complain if script is sourced in psql, rather than via ALTER EXTENSION +\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.3'" to load this file. \quit + +-- Add support for indexing UUID columns + +-- define the GiST support methods +CREATE FUNCTION gbt_uuid_consistent(internal,uuid,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_uuid_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_uuid_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_uuid_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_uuid_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_uuid_union(internal, internal) +RETURNS gbtreekey32 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_uuid_same(gbtreekey32, gbtreekey32, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_uuid_ops +DEFAULT FOR TYPE uuid USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_uuid_consistent (internal, uuid, int2, oid, internal), + FUNCTION 2 gbt_uuid_union (internal, internal), + FUNCTION 3 gbt_uuid_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_uuid_penalty (internal, internal, internal), + FUNCTION 6 gbt_uuid_picksplit (internal, internal), + FUNCTION 7 gbt_uuid_same (gbtreekey32, gbtreekey32, internal), + STORAGE gbtreekey32; + +-- These are "loose" in the opfamily for consistency with the rest of btree_gist +ALTER OPERATOR FAMILY gist_uuid_ops USING gist ADD + OPERATOR 6 <> (uuid, uuid) , + FUNCTION 9 (uuid, uuid) gbt_uuid_fetch (internal) ; diff --git a/contrib/btree_gist/btree_gist--1.2.sql b/contrib/btree_gist/btree_gist--1.2.sql new file mode 100644 index 0000000..1efe753 --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.2.sql @@ -0,0 +1,1570 @@ +/* contrib/btree_gist/btree_gist--1.2.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION btree_gist" to load this file. \quit + +CREATE FUNCTION gbtreekey4_in(cstring) +RETURNS gbtreekey4 +AS 'MODULE_PATHNAME', 'gbtreekey_in' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbtreekey4_out(gbtreekey4) +RETURNS cstring +AS 'MODULE_PATHNAME', 'gbtreekey_out' +LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE gbtreekey4 ( + INTERNALLENGTH = 4, + INPUT = gbtreekey4_in, + OUTPUT = gbtreekey4_out +); + +CREATE FUNCTION gbtreekey8_in(cstring) +RETURNS gbtreekey8 +AS 'MODULE_PATHNAME', 'gbtreekey_in' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbtreekey8_out(gbtreekey8) +RETURNS cstring +AS 'MODULE_PATHNAME', 'gbtreekey_out' +LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE gbtreekey8 ( + INTERNALLENGTH = 8, + INPUT = gbtreekey8_in, + OUTPUT = gbtreekey8_out +); + +CREATE FUNCTION gbtreekey16_in(cstring) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME', 'gbtreekey_in' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbtreekey16_out(gbtreekey16) +RETURNS cstring +AS 'MODULE_PATHNAME', 'gbtreekey_out' +LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE gbtreekey16 ( + INTERNALLENGTH = 16, + INPUT = gbtreekey16_in, + OUTPUT = gbtreekey16_out +); + +CREATE FUNCTION gbtreekey32_in(cstring) +RETURNS gbtreekey32 +AS 'MODULE_PATHNAME', 'gbtreekey_in' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbtreekey32_out(gbtreekey32) +RETURNS cstring +AS 'MODULE_PATHNAME', 'gbtreekey_out' +LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE gbtreekey32 ( + INTERNALLENGTH = 32, + INPUT = gbtreekey32_in, + OUTPUT = gbtreekey32_out +); + +CREATE FUNCTION gbtreekey_var_in(cstring) +RETURNS gbtreekey_var +AS 'MODULE_PATHNAME', 'gbtreekey_in' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbtreekey_var_out(gbtreekey_var) +RETURNS cstring +AS 'MODULE_PATHNAME', 'gbtreekey_out' +LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE gbtreekey_var ( + INTERNALLENGTH = VARIABLE, + INPUT = gbtreekey_var_in, + OUTPUT = gbtreekey_var_out, + STORAGE = EXTENDED +); + +--distance operators + +CREATE FUNCTION cash_dist(money, money) +RETURNS money +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = money, + RIGHTARG = money, + PROCEDURE = cash_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION date_dist(date, date) +RETURNS int4 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = date, + RIGHTARG = date, + PROCEDURE = date_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION float4_dist(float4, float4) +RETURNS float4 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = float4, + RIGHTARG = float4, + PROCEDURE = float4_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION float8_dist(float8, float8) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = float8, + RIGHTARG = float8, + PROCEDURE = float8_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION int2_dist(int2, int2) +RETURNS int2 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = int2, + RIGHTARG = int2, + PROCEDURE = int2_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION int4_dist(int4, int4) +RETURNS int4 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = int4, + RIGHTARG = int4, + PROCEDURE = int4_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION int8_dist(int8, int8) +RETURNS int8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = int8, + RIGHTARG = int8, + PROCEDURE = int8_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION interval_dist(interval, interval) +RETURNS interval +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = interval, + RIGHTARG = interval, + PROCEDURE = interval_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION oid_dist(oid, oid) +RETURNS oid +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = oid, + RIGHTARG = oid, + PROCEDURE = oid_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION time_dist(time, time) +RETURNS interval +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = time, + RIGHTARG = time, + PROCEDURE = time_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION ts_dist(timestamp, timestamp) +RETURNS interval +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = timestamp, + RIGHTARG = timestamp, + PROCEDURE = ts_dist, + COMMUTATOR = '<->' +); + +CREATE FUNCTION tstz_dist(timestamptz, timestamptz) +RETURNS interval +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE OPERATOR <-> ( + LEFTARG = timestamptz, + RIGHTARG = timestamptz, + PROCEDURE = tstz_dist, + COMMUTATOR = '<->' +); + + +-- +-- +-- +-- oid ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_oid_consistent(internal,oid,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_oid_distance(internal,oid,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_oid_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_oid_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_decompress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_var_decompress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_var_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_oid_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_oid_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_oid_union(internal, internal) +RETURNS gbtreekey8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_oid_same(gbtreekey8, gbtreekey8, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_oid_ops +DEFAULT FOR TYPE oid USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_oid_consistent (internal, oid, int2, oid, internal), + FUNCTION 2 gbt_oid_union (internal, internal), + FUNCTION 3 gbt_oid_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_oid_penalty (internal, internal, internal), + FUNCTION 6 gbt_oid_picksplit (internal, internal), + FUNCTION 7 gbt_oid_same (gbtreekey8, gbtreekey8, internal), + STORAGE gbtreekey8; + +-- Add operators that are new in 9.1. We do it like this, leaving them +-- "loose" in the operator family rather than bound into the opclass, because +-- that's the only state that can be reproduced during an upgrade from 9.0. +ALTER OPERATOR FAMILY gist_oid_ops USING gist ADD + OPERATOR 6 <> (oid, oid) , + OPERATOR 15 <-> (oid, oid) FOR ORDER BY pg_catalog.oid_ops , + FUNCTION 8 (oid, oid) gbt_oid_distance (internal, oid, int2, oid, internal) , + -- Also add support function for index-only-scans, added in 9.5. + FUNCTION 9 (oid, oid) gbt_oid_fetch (internal) ; + + +-- +-- +-- +-- int2 ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_int2_consistent(internal,int2,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_distance(internal,int2,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_union(internal, internal) +RETURNS gbtreekey4 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int2_same(gbtreekey4, gbtreekey4, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_int2_ops +DEFAULT FOR TYPE int2 USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_int2_consistent (internal, int2, int2, oid, internal), + FUNCTION 2 gbt_int2_union (internal, internal), + FUNCTION 3 gbt_int2_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_int2_penalty (internal, internal, internal), + FUNCTION 6 gbt_int2_picksplit (internal, internal), + FUNCTION 7 gbt_int2_same (gbtreekey4, gbtreekey4, internal), + STORAGE gbtreekey4; + +ALTER OPERATOR FAMILY gist_int2_ops USING gist ADD + OPERATOR 6 <> (int2, int2) , + OPERATOR 15 <-> (int2, int2) FOR ORDER BY pg_catalog.integer_ops , + FUNCTION 8 (int2, int2) gbt_int2_distance (internal, int2, int2, oid, internal) , + FUNCTION 9 (int2, int2) gbt_int2_fetch (internal) ; + +-- +-- +-- +-- int4 ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_int4_consistent(internal,int4,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_distance(internal,int4,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_union(internal, internal) +RETURNS gbtreekey8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int4_same(gbtreekey8, gbtreekey8, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_int4_ops +DEFAULT FOR TYPE int4 USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_int4_consistent (internal, int4, int2, oid, internal), + FUNCTION 2 gbt_int4_union (internal, internal), + FUNCTION 3 gbt_int4_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_int4_penalty (internal, internal, internal), + FUNCTION 6 gbt_int4_picksplit (internal, internal), + FUNCTION 7 gbt_int4_same (gbtreekey8, gbtreekey8, internal), + STORAGE gbtreekey8; + +ALTER OPERATOR FAMILY gist_int4_ops USING gist ADD + OPERATOR 6 <> (int4, int4) , + OPERATOR 15 <-> (int4, int4) FOR ORDER BY pg_catalog.integer_ops , + FUNCTION 8 (int4, int4) gbt_int4_distance (internal, int4, int2, oid, internal) , + FUNCTION 9 (int4, int4) gbt_int4_fetch (internal) ; + + +-- +-- +-- +-- int8 ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_int8_consistent(internal,int8,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_distance(internal,int8,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_int8_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_int8_ops +DEFAULT FOR TYPE int8 USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_int8_consistent (internal, int8, int2, oid, internal), + FUNCTION 2 gbt_int8_union (internal, internal), + FUNCTION 3 gbt_int8_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_int8_penalty (internal, internal, internal), + FUNCTION 6 gbt_int8_picksplit (internal, internal), + FUNCTION 7 gbt_int8_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_int8_ops USING gist ADD + OPERATOR 6 <> (int8, int8) , + OPERATOR 15 <-> (int8, int8) FOR ORDER BY pg_catalog.integer_ops , + FUNCTION 8 (int8, int8) gbt_int8_distance (internal, int8, int2, oid, internal) , + FUNCTION 9 (int8, int8) gbt_int8_fetch (internal) ; + +-- +-- +-- +-- float4 ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_float4_consistent(internal,float4,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_distance(internal,float4,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_union(internal, internal) +RETURNS gbtreekey8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float4_same(gbtreekey8, gbtreekey8, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_float4_ops +DEFAULT FOR TYPE float4 USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_float4_consistent (internal, float4, int2, oid, internal), + FUNCTION 2 gbt_float4_union (internal, internal), + FUNCTION 3 gbt_float4_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_float4_penalty (internal, internal, internal), + FUNCTION 6 gbt_float4_picksplit (internal, internal), + FUNCTION 7 gbt_float4_same (gbtreekey8, gbtreekey8, internal), + STORAGE gbtreekey8; + +ALTER OPERATOR FAMILY gist_float4_ops USING gist ADD + OPERATOR 6 <> (float4, float4) , + OPERATOR 15 <-> (float4, float4) FOR ORDER BY pg_catalog.float_ops , + FUNCTION 8 (float4, float4) gbt_float4_distance (internal, float4, int2, oid, internal) , + FUNCTION 9 (float4, float4) gbt_float4_fetch (internal) ; + +-- +-- +-- +-- float8 ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_float8_consistent(internal,float8,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_distance(internal,float8,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_float8_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_float8_ops +DEFAULT FOR TYPE float8 USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_float8_consistent (internal, float8, int2, oid, internal), + FUNCTION 2 gbt_float8_union (internal, internal), + FUNCTION 3 gbt_float8_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_float8_penalty (internal, internal, internal), + FUNCTION 6 gbt_float8_picksplit (internal, internal), + FUNCTION 7 gbt_float8_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_float8_ops USING gist ADD + OPERATOR 6 <> (float8, float8) , + OPERATOR 15 <-> (float8, float8) FOR ORDER BY pg_catalog.float_ops , + FUNCTION 8 (float8, float8) gbt_float8_distance (internal, float8, int2, oid, internal) , + FUNCTION 9 (float8, float8) gbt_float8_fetch (internal) ; + +-- +-- +-- +-- timestamp ops +-- +-- +-- + +CREATE FUNCTION gbt_ts_consistent(internal,timestamp,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_distance(internal,timestamp,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_tstz_distance(internal,timestamptz,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_tstz_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_ts_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_timestamp_ops +DEFAULT FOR TYPE timestamp USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_ts_consistent (internal, timestamp, int2, oid, internal), + FUNCTION 2 gbt_ts_union (internal, internal), + FUNCTION 3 gbt_ts_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_ts_penalty (internal, internal, internal), + FUNCTION 6 gbt_ts_picksplit (internal, internal), + FUNCTION 7 gbt_ts_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_timestamp_ops USING gist ADD + OPERATOR 6 <> (timestamp, timestamp) , + OPERATOR 15 <-> (timestamp, timestamp) FOR ORDER BY pg_catalog.interval_ops , + FUNCTION 8 (timestamp, timestamp) gbt_ts_distance (internal, timestamp, int2, oid, internal) , + FUNCTION 9 (timestamp, timestamp) gbt_ts_fetch (internal) ; + +-- Create the operator class +CREATE OPERATOR CLASS gist_timestamptz_ops +DEFAULT FOR TYPE timestamptz USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_tstz_consistent (internal, timestamptz, int2, oid, internal), + FUNCTION 2 gbt_ts_union (internal, internal), + FUNCTION 3 gbt_tstz_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_ts_penalty (internal, internal, internal), + FUNCTION 6 gbt_ts_picksplit (internal, internal), + FUNCTION 7 gbt_ts_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_timestamptz_ops USING gist ADD + OPERATOR 6 <> (timestamptz, timestamptz) , + OPERATOR 15 <-> (timestamptz, timestamptz) FOR ORDER BY pg_catalog.interval_ops , + FUNCTION 8 (timestamptz, timestamptz) gbt_tstz_distance (internal, timestamptz, int2, oid, internal) , + FUNCTION 9 (timestamptz, timestamptz) gbt_ts_fetch (internal) ; + +-- +-- +-- +-- time ops +-- +-- +-- + +CREATE FUNCTION gbt_time_consistent(internal,time,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_distance(internal,time,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_timetz_consistent(internal,timetz,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_timetz_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_time_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_time_ops +DEFAULT FOR TYPE time USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_time_consistent (internal, time, int2, oid, internal), + FUNCTION 2 gbt_time_union (internal, internal), + FUNCTION 3 gbt_time_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_time_penalty (internal, internal, internal), + FUNCTION 6 gbt_time_picksplit (internal, internal), + FUNCTION 7 gbt_time_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_time_ops USING gist ADD + OPERATOR 6 <> (time, time) , + OPERATOR 15 <-> (time, time) FOR ORDER BY pg_catalog.interval_ops , + FUNCTION 8 (time, time) gbt_time_distance (internal, time, int2, oid, internal) , + FUNCTION 9 (time, time) gbt_time_fetch (internal) ; + + +CREATE OPERATOR CLASS gist_timetz_ops +DEFAULT FOR TYPE timetz USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_timetz_consistent (internal, timetz, int2, oid, internal), + FUNCTION 2 gbt_time_union (internal, internal), + FUNCTION 3 gbt_timetz_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_time_penalty (internal, internal, internal), + FUNCTION 6 gbt_time_picksplit (internal, internal), + FUNCTION 7 gbt_time_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_timetz_ops USING gist ADD + OPERATOR 6 <> (timetz, timetz) ; + -- no 'fetch' function, as the compress function is lossy. + + +-- +-- +-- +-- date ops +-- +-- +-- + +CREATE FUNCTION gbt_date_consistent(internal,date,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_distance(internal,date,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_union(internal, internal) +RETURNS gbtreekey8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_date_same(gbtreekey8, gbtreekey8, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_date_ops +DEFAULT FOR TYPE date USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_date_consistent (internal, date, int2, oid, internal), + FUNCTION 2 gbt_date_union (internal, internal), + FUNCTION 3 gbt_date_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_date_penalty (internal, internal, internal), + FUNCTION 6 gbt_date_picksplit (internal, internal), + FUNCTION 7 gbt_date_same (gbtreekey8, gbtreekey8, internal), + STORAGE gbtreekey8; + +ALTER OPERATOR FAMILY gist_date_ops USING gist ADD + OPERATOR 6 <> (date, date) , + OPERATOR 15 <-> (date, date) FOR ORDER BY pg_catalog.integer_ops , + FUNCTION 8 (date, date) gbt_date_distance (internal, date, int2, oid, internal) , + FUNCTION 9 (date, date) gbt_date_fetch (internal) ; + + +-- +-- +-- +-- interval ops +-- +-- +-- + +CREATE FUNCTION gbt_intv_consistent(internal,interval,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_distance(internal,interval,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_decompress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_union(internal, internal) +RETURNS gbtreekey32 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_intv_same(gbtreekey32, gbtreekey32, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_interval_ops +DEFAULT FOR TYPE interval USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_intv_consistent (internal, interval, int2, oid, internal), + FUNCTION 2 gbt_intv_union (internal, internal), + FUNCTION 3 gbt_intv_compress (internal), + FUNCTION 4 gbt_intv_decompress (internal), + FUNCTION 5 gbt_intv_penalty (internal, internal, internal), + FUNCTION 6 gbt_intv_picksplit (internal, internal), + FUNCTION 7 gbt_intv_same (gbtreekey32, gbtreekey32, internal), + STORAGE gbtreekey32; + +ALTER OPERATOR FAMILY gist_interval_ops USING gist ADD + OPERATOR 6 <> (interval, interval) , + OPERATOR 15 <-> (interval, interval) FOR ORDER BY pg_catalog.interval_ops , + FUNCTION 8 (interval, interval) gbt_intv_distance (internal, interval, int2, oid, internal) , + FUNCTION 9 (interval, interval) gbt_intv_fetch (internal) ; + + +-- +-- +-- +-- cash ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_cash_consistent(internal,money,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_distance(internal,money,int2,oid,internal) +RETURNS float8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_cash_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_cash_ops +DEFAULT FOR TYPE money USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_cash_consistent (internal, money, int2, oid, internal), + FUNCTION 2 gbt_cash_union (internal, internal), + FUNCTION 3 gbt_cash_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_cash_penalty (internal, internal, internal), + FUNCTION 6 gbt_cash_picksplit (internal, internal), + FUNCTION 7 gbt_cash_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_cash_ops USING gist ADD + OPERATOR 6 <> (money, money) , + OPERATOR 15 <-> (money, money) FOR ORDER BY pg_catalog.money_ops , + FUNCTION 8 (money, money) gbt_cash_distance (internal, money, int2, oid, internal) , + FUNCTION 9 (money, money) gbt_cash_fetch (internal) ; + + +-- +-- +-- +-- macaddr ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_macad_consistent(internal,macaddr,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_macaddr_ops +DEFAULT FOR TYPE macaddr USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_macad_consistent (internal, macaddr, int2, oid, internal), + FUNCTION 2 gbt_macad_union (internal, internal), + FUNCTION 3 gbt_macad_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_macad_penalty (internal, internal, internal), + FUNCTION 6 gbt_macad_picksplit (internal, internal), + FUNCTION 7 gbt_macad_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_macaddr_ops USING gist ADD + OPERATOR 6 <> (macaddr, macaddr) , + FUNCTION 9 (macaddr, macaddr) gbt_macad_fetch (internal); + + +-- +-- +-- +-- text/ bpchar ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_text_consistent(internal,text,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_text_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bpchar_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_text_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_text_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_text_union(internal, internal) +RETURNS gbtreekey_var +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_text_same(gbtreekey_var, gbtreekey_var, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_text_ops +DEFAULT FOR TYPE text USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_text_consistent (internal, text, int2, oid, internal), + FUNCTION 2 gbt_text_union (internal, internal), + FUNCTION 3 gbt_text_compress (internal), + FUNCTION 4 gbt_var_decompress (internal), + FUNCTION 5 gbt_text_penalty (internal, internal, internal), + FUNCTION 6 gbt_text_picksplit (internal, internal), + FUNCTION 7 gbt_text_same (gbtreekey_var, gbtreekey_var, internal), + STORAGE gbtreekey_var; + +ALTER OPERATOR FAMILY gist_text_ops USING gist ADD + OPERATOR 6 <> (text, text) , + FUNCTION 9 (text, text) gbt_var_fetch (internal) ; + + +---- Create the operator class +CREATE OPERATOR CLASS gist_bpchar_ops +DEFAULT FOR TYPE bpchar USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_bpchar_consistent (internal, bpchar , int2, oid, internal), + FUNCTION 2 gbt_text_union (internal, internal), + FUNCTION 3 gbt_bpchar_compress (internal), + FUNCTION 4 gbt_var_decompress (internal), + FUNCTION 5 gbt_text_penalty (internal, internal, internal), + FUNCTION 6 gbt_text_picksplit (internal, internal), + FUNCTION 7 gbt_text_same (gbtreekey_var, gbtreekey_var, internal), + STORAGE gbtreekey_var; + +ALTER OPERATOR FAMILY gist_bpchar_ops USING gist ADD + OPERATOR 6 <> (bpchar, bpchar) , + FUNCTION 9 (bpchar, bpchar) gbt_var_fetch (internal) ; + +-- +-- +-- bytea ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_bytea_consistent(internal,bytea,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bytea_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bytea_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bytea_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bytea_union(internal, internal) +RETURNS gbtreekey_var +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bytea_same(gbtreekey_var, gbtreekey_var, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_bytea_ops +DEFAULT FOR TYPE bytea USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_bytea_consistent (internal, bytea, int2, oid, internal), + FUNCTION 2 gbt_bytea_union (internal, internal), + FUNCTION 3 gbt_bytea_compress (internal), + FUNCTION 4 gbt_var_decompress (internal), + FUNCTION 5 gbt_bytea_penalty (internal, internal, internal), + FUNCTION 6 gbt_bytea_picksplit (internal, internal), + FUNCTION 7 gbt_bytea_same (gbtreekey_var, gbtreekey_var, internal), + STORAGE gbtreekey_var; + +ALTER OPERATOR FAMILY gist_bytea_ops USING gist ADD + OPERATOR 6 <> (bytea, bytea) , + FUNCTION 9 (bytea, bytea) gbt_var_fetch (internal) ; + + +-- +-- +-- +-- numeric ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_numeric_consistent(internal,numeric,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_numeric_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_numeric_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_numeric_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_numeric_union(internal, internal) +RETURNS gbtreekey_var +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_numeric_same(gbtreekey_var, gbtreekey_var, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_numeric_ops +DEFAULT FOR TYPE numeric USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_numeric_consistent (internal, numeric, int2, oid, internal), + FUNCTION 2 gbt_numeric_union (internal, internal), + FUNCTION 3 gbt_numeric_compress (internal), + FUNCTION 4 gbt_var_decompress (internal), + FUNCTION 5 gbt_numeric_penalty (internal, internal, internal), + FUNCTION 6 gbt_numeric_picksplit (internal, internal), + FUNCTION 7 gbt_numeric_same (gbtreekey_var, gbtreekey_var, internal), + STORAGE gbtreekey_var; + +ALTER OPERATOR FAMILY gist_numeric_ops USING gist ADD + OPERATOR 6 <> (numeric, numeric) , + FUNCTION 9 (numeric, numeric) gbt_var_fetch (internal) ; + + +-- +-- +-- bit ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_bit_consistent(internal,bit,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bit_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bit_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bit_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bit_union(internal, internal) +RETURNS gbtreekey_var +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bit_same(gbtreekey_var, gbtreekey_var, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_bit_ops +DEFAULT FOR TYPE bit USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_bit_consistent (internal, bit, int2, oid, internal), + FUNCTION 2 gbt_bit_union (internal, internal), + FUNCTION 3 gbt_bit_compress (internal), + FUNCTION 4 gbt_var_decompress (internal), + FUNCTION 5 gbt_bit_penalty (internal, internal, internal), + FUNCTION 6 gbt_bit_picksplit (internal, internal), + FUNCTION 7 gbt_bit_same (gbtreekey_var, gbtreekey_var, internal), + STORAGE gbtreekey_var; + +ALTER OPERATOR FAMILY gist_bit_ops USING gist ADD + OPERATOR 6 <> (bit, bit) , + FUNCTION 9 (bit, bit) gbt_var_fetch (internal) ; + + +-- Create the operator class +CREATE OPERATOR CLASS gist_vbit_ops +DEFAULT FOR TYPE varbit USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_bit_consistent (internal, bit, int2, oid, internal), + FUNCTION 2 gbt_bit_union (internal, internal), + FUNCTION 3 gbt_bit_compress (internal), + FUNCTION 4 gbt_var_decompress (internal), + FUNCTION 5 gbt_bit_penalty (internal, internal, internal), + FUNCTION 6 gbt_bit_picksplit (internal, internal), + FUNCTION 7 gbt_bit_same (gbtreekey_var, gbtreekey_var, internal), + STORAGE gbtreekey_var; + +ALTER OPERATOR FAMILY gist_vbit_ops USING gist ADD + OPERATOR 6 <> (varbit, varbit) , + FUNCTION 9 (varbit, varbit) gbt_var_fetch (internal) ; + + +-- +-- +-- +-- inet/cidr ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_inet_consistent(internal,inet,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_inet_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_inet_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_inet_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_inet_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_inet_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_inet_ops +DEFAULT FOR TYPE inet USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_inet_consistent (internal, inet, int2, oid, internal), + FUNCTION 2 gbt_inet_union (internal, internal), + FUNCTION 3 gbt_inet_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_inet_penalty (internal, internal, internal), + FUNCTION 6 gbt_inet_picksplit (internal, internal), + FUNCTION 7 gbt_inet_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_inet_ops USING gist ADD + OPERATOR 6 <> (inet, inet) ; + -- no fetch support, the compress function is lossy + +-- Create the operator class +CREATE OPERATOR CLASS gist_cidr_ops +DEFAULT FOR TYPE cidr USING gist +AS + OPERATOR 1 < (inet, inet) , + OPERATOR 2 <= (inet, inet) , + OPERATOR 3 = (inet, inet) , + OPERATOR 4 >= (inet, inet) , + OPERATOR 5 > (inet, inet) , + FUNCTION 1 gbt_inet_consistent (internal, inet, int2, oid, internal), + FUNCTION 2 gbt_inet_union (internal, internal), + FUNCTION 3 gbt_inet_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_inet_penalty (internal, internal, internal), + FUNCTION 6 gbt_inet_picksplit (internal, internal), + FUNCTION 7 gbt_inet_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_cidr_ops USING gist ADD + OPERATOR 6 <> (inet, inet) ; + -- no fetch support, the compress function is lossy diff --git a/contrib/btree_gist/btree_gist--1.3--1.4.sql b/contrib/btree_gist/btree_gist--1.3--1.4.sql new file mode 100644 index 0000000..f77f6c8 --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.3--1.4.sql @@ -0,0 +1,64 @@ +/* contrib/btree_gist/btree_gist--1.3--1.4.sql */ + +-- complain if script is sourced in psql, rather than via ALTER EXTENSION +\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.4'" to load this file. \quit + +-- Add support for indexing macaddr8 columns + +-- define the GiST support methods +CREATE FUNCTION gbt_macad8_consistent(internal,macaddr8,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad8_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad8_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad8_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad8_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad8_union(internal, internal) +RETURNS gbtreekey16 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_macad8_same(gbtreekey16, gbtreekey16, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_macaddr8_ops +DEFAULT FOR TYPE macaddr8 USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_macad8_consistent (internal, macaddr8, int2, oid, internal), + FUNCTION 2 gbt_macad8_union (internal, internal), + FUNCTION 3 gbt_macad8_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_macad8_penalty (internal, internal, internal), + FUNCTION 6 gbt_macad8_picksplit (internal, internal), + FUNCTION 7 gbt_macad8_same (gbtreekey16, gbtreekey16, internal), + STORAGE gbtreekey16; + +ALTER OPERATOR FAMILY gist_macaddr8_ops USING gist ADD + OPERATOR 6 <> (macaddr8, macaddr8) , + FUNCTION 9 (macaddr8, macaddr8) gbt_macad8_fetch (internal); diff --git a/contrib/btree_gist/btree_gist--1.4--1.5.sql b/contrib/btree_gist/btree_gist--1.4--1.5.sql new file mode 100644 index 0000000..cf974c2 --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.4--1.5.sql @@ -0,0 +1,69 @@ +/* contrib/btree_gist/btree_gist--1.4--1.5.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.5'" to load this file. \quit + +-- +-- +-- +-- enum ops +-- +-- +-- +-- define the GiST support methods +CREATE FUNCTION gbt_enum_consistent(internal,anyenum,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_enum_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_enum_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_enum_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_enum_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_enum_union(internal, internal) +RETURNS gbtreekey8 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_enum_same(gbtreekey8, gbtreekey8, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_enum_ops +DEFAULT FOR TYPE anyenum USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 gbt_enum_consistent (internal, anyenum, int2, oid, internal), + FUNCTION 2 gbt_enum_union (internal, internal), + FUNCTION 3 gbt_enum_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_enum_penalty (internal, internal, internal), + FUNCTION 6 gbt_enum_picksplit (internal, internal), + FUNCTION 7 gbt_enum_same (gbtreekey8, gbtreekey8, internal), + STORAGE gbtreekey8; + +ALTER OPERATOR FAMILY gist_enum_ops USING gist ADD + OPERATOR 6 <> (anyenum, anyenum) , + FUNCTION 9 (anyenum, anyenum) gbt_enum_fetch (internal) ; diff --git a/contrib/btree_gist/btree_gist--1.5--1.6.sql b/contrib/btree_gist/btree_gist--1.5--1.6.sql new file mode 100644 index 0000000..5e1fcb4 --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.5--1.6.sql @@ -0,0 +1,191 @@ +/* contrib/btree_gist/btree_gist--1.5--1.6.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.6'" to load this file. \quit + +-- This upgrade script marks all btree_gist functions as parallel safe. + +-- Input/output functions for GiST key types (gbtreekey*) +ALTER FUNCTION gbtreekey4_in(cstring) PARALLEL SAFE; +ALTER FUNCTION gbtreekey4_out(gbtreekey4) PARALLEL SAFE; +ALTER FUNCTION gbtreekey8_in(cstring) PARALLEL SAFE; +ALTER FUNCTION gbtreekey8_out(gbtreekey8) PARALLEL SAFE; +ALTER FUNCTION gbtreekey16_in(cstring) PARALLEL SAFE; +ALTER FUNCTION gbtreekey16_out(gbtreekey16) PARALLEL SAFE; +ALTER FUNCTION gbtreekey32_in(cstring) PARALLEL SAFE; +ALTER FUNCTION gbtreekey32_out(gbtreekey32) PARALLEL SAFE; +ALTER FUNCTION gbtreekey_var_in(cstring) PARALLEL SAFE; +ALTER FUNCTION gbtreekey_var_out(gbtreekey_var) PARALLEL SAFE; + +-- Functions, which implement distance operators (<->) +ALTER FUNCTION cash_dist(money, money) PARALLEL SAFE; +ALTER FUNCTION date_dist(date, date) PARALLEL SAFE; +ALTER FUNCTION float4_dist(real, real) PARALLEL SAFE; +ALTER FUNCTION float8_dist(double precision, double precision) PARALLEL SAFE; +ALTER FUNCTION int2_dist(smallint, smallint) PARALLEL SAFE; +ALTER FUNCTION int4_dist(integer, integer) PARALLEL SAFE; +ALTER FUNCTION int8_dist(bigint, bigint) PARALLEL SAFE; +ALTER FUNCTION interval_dist(interval, interval) PARALLEL SAFE; +ALTER FUNCTION oid_dist(oid, oid) PARALLEL SAFE; +ALTER FUNCTION time_dist(time without time zone, time without time zone) PARALLEL SAFE; +ALTER FUNCTION ts_dist(timestamp without time zone, timestamp without time zone) PARALLEL SAFE; +ALTER FUNCTION tstz_dist(timestamp with time zone, timestamp with time zone) PARALLEL SAFE; + +-- GiST support methods +ALTER FUNCTION gbt_oid_consistent(internal, oid, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_oid_distance(internal, oid, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_oid_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_oid_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_decompress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_var_decompress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_var_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_oid_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_oid_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_oid_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_oid_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_consistent(internal, smallint, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_distance(internal, smallint, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int2_same(gbtreekey4, gbtreekey4, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_consistent(internal, integer, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_distance(internal, integer, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int4_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_consistent(internal, bigint, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_distance(internal, bigint, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_int8_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_consistent(internal, real, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_distance(internal, real, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float4_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_consistent(internal, double precision, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_distance(internal, double precision, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_float8_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_consistent(internal, timestamp without time zone, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_distance(internal, timestamp without time zone, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_tstz_consistent(internal, timestamp with time zone, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_tstz_distance(internal, timestamp with time zone, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_tstz_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_ts_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_consistent(internal, time without time zone, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_distance(internal, time without time zone, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_timetz_consistent(internal, time with time zone, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_timetz_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_time_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_consistent(internal, date, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_distance(internal, date, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_date_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_consistent(internal, interval, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_distance(internal, interval, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_decompress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_intv_same(gbtreekey32, gbtreekey32, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_consistent(internal, money, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_distance(internal, money, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_cash_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad_consistent(internal, macaddr, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_text_consistent(internal, text, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bpchar_consistent(internal, character, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_text_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bpchar_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_text_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_text_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_text_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_text_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bytea_consistent(internal, bytea, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bytea_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bytea_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bytea_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bytea_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bytea_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_numeric_consistent(internal, numeric, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_numeric_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_numeric_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_numeric_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_numeric_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_numeric_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bit_consistent(internal, bit, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bit_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bit_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bit_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bit_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_bit_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_inet_consistent(internal, inet, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_inet_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_inet_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_inet_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_inet_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_inet_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_uuid_consistent(internal, uuid, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_uuid_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_uuid_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_uuid_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_uuid_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_uuid_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_uuid_same(gbtreekey32, gbtreekey32, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad8_consistent(internal, macaddr8, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad8_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad8_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad8_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad8_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad8_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_macad8_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_enum_consistent(internal, anyenum, smallint, oid, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_enum_compress(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_enum_fetch(internal) PARALLEL SAFE; +ALTER FUNCTION gbt_enum_penalty(internal, internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_enum_picksplit(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_enum_union(internal, internal) PARALLEL SAFE; +ALTER FUNCTION gbt_enum_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE; diff --git a/contrib/btree_gist/btree_gist--1.6--1.7.sql b/contrib/btree_gist/btree_gist--1.6--1.7.sql new file mode 100644 index 0000000..1085216 --- /dev/null +++ b/contrib/btree_gist/btree_gist--1.6--1.7.sql @@ -0,0 +1,77 @@ +/* contrib/btree_gist/btree_gist--1.6--1.7.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.7'" to load this file. \quit + +-- This upgrade scripts add support for bool. +CREATE FUNCTION gbtreekey2_in(cstring) +RETURNS gbtreekey2 +AS 'MODULE_PATHNAME', 'gbtreekey_in' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION gbtreekey2_out(gbtreekey2) +RETURNS cstring +AS 'MODULE_PATHNAME', 'gbtreekey_out' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE gbtreekey2 ( + INTERNALLENGTH = 2, + INPUT = gbtreekey2_in, + OUTPUT = gbtreekey2_out +); + +-- Define the GiST support methods +CREATE FUNCTION gbt_bool_consistent(internal,bool,int2,oid,internal) +RETURNS bool +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bool_compress(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bool_fetch(internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bool_penalty(internal,internal,internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bool_picksplit(internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bool_union(internal, internal) +RETURNS gbtreekey2 +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION gbt_bool_same(gbtreekey2, gbtreekey2, internal) +RETURNS internal +AS 'MODULE_PATHNAME' +LANGUAGE C IMMUTABLE STRICT; + +-- Create the operator class +CREATE OPERATOR CLASS gist_bool_ops +DEFAULT FOR TYPE bool USING gist +AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + OPERATOR 6 <> , + FUNCTION 1 gbt_bool_consistent (internal, bool, int2, oid, internal), + FUNCTION 2 gbt_bool_union (internal, internal), + FUNCTION 3 gbt_bool_compress (internal), + FUNCTION 4 gbt_decompress (internal), + FUNCTION 5 gbt_bool_penalty (internal, internal, internal), + FUNCTION 6 gbt_bool_picksplit (internal, internal), + FUNCTION 7 gbt_bool_same (gbtreekey2, gbtreekey2, internal), + FUNCTION 9 gbt_bool_fetch (internal), + STORAGE gbtreekey2; diff --git a/contrib/btree_gist/btree_gist.c b/contrib/btree_gist/btree_gist.c new file mode 100644 index 0000000..e1dc253 --- /dev/null +++ b/contrib/btree_gist/btree_gist.c @@ -0,0 +1,49 @@ +/* + * contrib/btree_gist/btree_gist.c + */ +#include "postgres.h" + +#include "btree_gist.h" + +PG_MODULE_MAGIC; + +PG_FUNCTION_INFO_V1(gbt_decompress); +PG_FUNCTION_INFO_V1(gbtreekey_in); +PG_FUNCTION_INFO_V1(gbtreekey_out); + +/************************************************** + * In/Out for keys + **************************************************/ + + +Datum +gbtreekey_in(PG_FUNCTION_ARGS) +{ + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("<datatype>key_in() not implemented"))); + + PG_RETURN_POINTER(NULL); +} + +#include "btree_utils_var.h" +#include "utils/builtins.h" +Datum +gbtreekey_out(PG_FUNCTION_ARGS) +{ + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("<datatype>key_out() not implemented"))); + PG_RETURN_POINTER(NULL); +} + + +/* +** GiST DeCompress methods +** do not do anything. +*/ +Datum +gbt_decompress(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(PG_GETARG_POINTER(0)); +} diff --git a/contrib/btree_gist/btree_gist.control b/contrib/btree_gist/btree_gist.control new file mode 100644 index 0000000..fa9171a --- /dev/null +++ b/contrib/btree_gist/btree_gist.control @@ -0,0 +1,6 @@ +# btree_gist extension +comment = 'support for indexing common datatypes in GiST' +default_version = '1.7' +module_pathname = '$libdir/btree_gist' +relocatable = true +trusted = true diff --git a/contrib/btree_gist/btree_gist.h b/contrib/btree_gist/btree_gist.h new file mode 100644 index 0000000..f22f14a --- /dev/null +++ b/contrib/btree_gist/btree_gist.h @@ -0,0 +1,41 @@ +/* + * contrib/btree_gist/btree_gist.h + */ +#ifndef __BTREE_GIST_H__ +#define __BTREE_GIST_H__ + +#include "access/nbtree.h" +#include "fmgr.h" + +#define BtreeGistNotEqualStrategyNumber 6 + +/* indexed types */ + +enum gbtree_type +{ + gbt_t_var, + gbt_t_int2, + gbt_t_int4, + gbt_t_int8, + gbt_t_float4, + gbt_t_float8, + gbt_t_numeric, + gbt_t_ts, + gbt_t_cash, + gbt_t_oid, + gbt_t_time, + gbt_t_date, + gbt_t_intv, + gbt_t_macad, + gbt_t_macad8, + gbt_t_text, + gbt_t_bpchar, + gbt_t_bytea, + gbt_t_bit, + gbt_t_bool, + gbt_t_inet, + gbt_t_uuid, + gbt_t_enum +}; + +#endif diff --git a/contrib/btree_gist/btree_inet.c b/contrib/btree_gist/btree_inet.c new file mode 100644 index 0000000..2fb952d --- /dev/null +++ b/contrib/btree_gist/btree_inet.c @@ -0,0 +1,187 @@ +/* + * contrib/btree_gist/btree_inet.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "catalog/pg_type.h" +#include "utils/builtins.h" +#include "utils/inet.h" + +typedef struct inetkey +{ + double lower; + double upper; +} inetKEY; + +/* +** inet ops +*/ +PG_FUNCTION_INFO_V1(gbt_inet_compress); +PG_FUNCTION_INFO_V1(gbt_inet_union); +PG_FUNCTION_INFO_V1(gbt_inet_picksplit); +PG_FUNCTION_INFO_V1(gbt_inet_consistent); +PG_FUNCTION_INFO_V1(gbt_inet_penalty); +PG_FUNCTION_INFO_V1(gbt_inet_same); + + +static bool +gbt_inetgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const double *) a) > *((const double *) b)); +} +static bool +gbt_inetge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const double *) a) >= *((const double *) b)); +} +static bool +gbt_ineteq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const double *) a) == *((const double *) b)); +} +static bool +gbt_inetle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const double *) a) <= *((const double *) b)); +} +static bool +gbt_inetlt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const double *) a) < *((const double *) b)); +} + +static int +gbt_inetkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + inetKEY *ia = (inetKEY *) (((const Nsrt *) a)->t); + inetKEY *ib = (inetKEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_inet, + sizeof(double), + 16, /* sizeof(gbtreekey16) */ + gbt_inetgt, + gbt_inetge, + gbt_ineteq, + gbt_inetle, + gbt_inetlt, + gbt_inetkey_cmp, + NULL +}; + + +/************************************************** + * inet ops + **************************************************/ + + +Datum +gbt_inet_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; + + if (entry->leafkey) + { + inetKEY *r = (inetKEY *) palloc(sizeof(inetKEY)); + bool failure = false; + + retval = palloc(sizeof(GISTENTRY)); + r->lower = convert_network_to_scalar(entry->key, INETOID, &failure); + Assert(!failure); + r->upper = r->lower; + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, false); + } + else + retval = entry; + + PG_RETURN_POINTER(retval); +} + + +Datum +gbt_inet_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Datum dquery = PG_GETARG_DATUM(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + inetKEY *kkk = (inetKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + double query; + bool failure = false; + + query = convert_network_to_scalar(dquery, INETOID, &failure); + Assert(!failure); + + /* All cases served by this function are inexact */ + *recheck = true; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, + &strategy, GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_inet_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(inetKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(inetKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_inet_penalty(PG_FUNCTION_ARGS) +{ + inetKEY *origentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + inetKEY *newentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_inet_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_inet_same(PG_FUNCTION_ARGS) +{ + inetKEY *b1 = (inetKEY *) PG_GETARG_POINTER(0); + inetKEY *b2 = (inetKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_int2.c b/contrib/btree_gist/btree_int2.c new file mode 100644 index 0000000..a91b95f --- /dev/null +++ b/contrib/btree_gist/btree_int2.c @@ -0,0 +1,216 @@ +/* + * contrib/btree_gist/btree_int2.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "common/int.h" + +typedef struct int16key +{ + int16 lower; + int16 upper; +} int16KEY; + +/* +** int16 ops +*/ +PG_FUNCTION_INFO_V1(gbt_int2_compress); +PG_FUNCTION_INFO_V1(gbt_int2_fetch); +PG_FUNCTION_INFO_V1(gbt_int2_union); +PG_FUNCTION_INFO_V1(gbt_int2_picksplit); +PG_FUNCTION_INFO_V1(gbt_int2_consistent); +PG_FUNCTION_INFO_V1(gbt_int2_distance); +PG_FUNCTION_INFO_V1(gbt_int2_penalty); +PG_FUNCTION_INFO_V1(gbt_int2_same); + +static bool +gbt_int2gt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int16 *) a) > *((const int16 *) b)); +} +static bool +gbt_int2ge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int16 *) a) >= *((const int16 *) b)); +} +static bool +gbt_int2eq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int16 *) a) == *((const int16 *) b)); +} +static bool +gbt_int2le(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int16 *) a) <= *((const int16 *) b)); +} +static bool +gbt_int2lt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int16 *) a) < *((const int16 *) b)); +} + +static int +gbt_int2key_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + int16KEY *ia = (int16KEY *) (((const Nsrt *) a)->t); + int16KEY *ib = (int16KEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + +static float8 +gbt_int2_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + return GET_FLOAT_DISTANCE(int16, a, b); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_int2, + sizeof(int16), + 4, /* sizeof(gbtreekey4) */ + gbt_int2gt, + gbt_int2ge, + gbt_int2eq, + gbt_int2le, + gbt_int2lt, + gbt_int2key_cmp, + gbt_int2_dist +}; + + +PG_FUNCTION_INFO_V1(int2_dist); +Datum +int2_dist(PG_FUNCTION_ARGS) +{ + int16 a = PG_GETARG_INT16(0); + int16 b = PG_GETARG_INT16(1); + int16 r; + int16 ra; + + if (pg_sub_s16_overflow(a, b, &r) || + r == PG_INT16_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("smallint out of range"))); + + ra = Abs(r); + + PG_RETURN_INT16(ra); +} + + +/************************************************** + * int16 ops + **************************************************/ + + +Datum +gbt_int2_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_int2_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_int2_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int16 query = PG_GETARG_INT16(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + int16KEY *kkk = (int16KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int2_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int16 query = PG_GETARG_INT16(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + int16KEY *kkk = (int16KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int2_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(int16KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(int16KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int2_penalty(PG_FUNCTION_ARGS) +{ + int16KEY *origentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + int16KEY *newentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_int2_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_int2_same(PG_FUNCTION_ARGS) +{ + int16KEY *b1 = (int16KEY *) PG_GETARG_POINTER(0); + int16KEY *b2 = (int16KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_int4.c b/contrib/btree_gist/btree_int4.c new file mode 100644 index 0000000..7ea98c4 --- /dev/null +++ b/contrib/btree_gist/btree_int4.c @@ -0,0 +1,217 @@ +/* + * contrib/btree_gist/btree_int4.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "common/int.h" + +typedef struct int32key +{ + int32 lower; + int32 upper; +} int32KEY; + +/* +** int32 ops +*/ +PG_FUNCTION_INFO_V1(gbt_int4_compress); +PG_FUNCTION_INFO_V1(gbt_int4_fetch); +PG_FUNCTION_INFO_V1(gbt_int4_union); +PG_FUNCTION_INFO_V1(gbt_int4_picksplit); +PG_FUNCTION_INFO_V1(gbt_int4_consistent); +PG_FUNCTION_INFO_V1(gbt_int4_distance); +PG_FUNCTION_INFO_V1(gbt_int4_penalty); +PG_FUNCTION_INFO_V1(gbt_int4_same); + + +static bool +gbt_int4gt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int32 *) a) > *((const int32 *) b)); +} +static bool +gbt_int4ge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int32 *) a) >= *((const int32 *) b)); +} +static bool +gbt_int4eq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int32 *) a) == *((const int32 *) b)); +} +static bool +gbt_int4le(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int32 *) a) <= *((const int32 *) b)); +} +static bool +gbt_int4lt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int32 *) a) < *((const int32 *) b)); +} + +static int +gbt_int4key_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + int32KEY *ia = (int32KEY *) (((const Nsrt *) a)->t); + int32KEY *ib = (int32KEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + +static float8 +gbt_int4_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + return GET_FLOAT_DISTANCE(int32, a, b); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_int4, + sizeof(int32), + 8, /* sizeof(gbtreekey8) */ + gbt_int4gt, + gbt_int4ge, + gbt_int4eq, + gbt_int4le, + gbt_int4lt, + gbt_int4key_cmp, + gbt_int4_dist +}; + + +PG_FUNCTION_INFO_V1(int4_dist); +Datum +int4_dist(PG_FUNCTION_ARGS) +{ + int32 a = PG_GETARG_INT32(0); + int32 b = PG_GETARG_INT32(1); + int32 r; + int32 ra; + + if (pg_sub_s32_overflow(a, b, &r) || + r == PG_INT32_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("integer out of range"))); + + ra = Abs(r); + + PG_RETURN_INT32(ra); +} + + +/************************************************** + * int32 ops + **************************************************/ + + +Datum +gbt_int4_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_int4_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_int4_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int32 query = PG_GETARG_INT32(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + int32KEY *kkk = (int32KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int4_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int32 query = PG_GETARG_INT32(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + int32KEY *kkk = (int32KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int4_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(int32KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(int32KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int4_penalty(PG_FUNCTION_ARGS) +{ + int32KEY *origentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + int32KEY *newentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_int4_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_int4_same(PG_FUNCTION_ARGS) +{ + int32KEY *b1 = (int32KEY *) PG_GETARG_POINTER(0); + int32KEY *b2 = (int32KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_int8.c b/contrib/btree_gist/btree_int8.c new file mode 100644 index 0000000..df2b0d1 --- /dev/null +++ b/contrib/btree_gist/btree_int8.c @@ -0,0 +1,217 @@ +/* + * contrib/btree_gist/btree_int8.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "common/int.h" + +typedef struct int64key +{ + int64 lower; + int64 upper; +} int64KEY; + +/* +** int64 ops +*/ +PG_FUNCTION_INFO_V1(gbt_int8_compress); +PG_FUNCTION_INFO_V1(gbt_int8_fetch); +PG_FUNCTION_INFO_V1(gbt_int8_union); +PG_FUNCTION_INFO_V1(gbt_int8_picksplit); +PG_FUNCTION_INFO_V1(gbt_int8_consistent); +PG_FUNCTION_INFO_V1(gbt_int8_distance); +PG_FUNCTION_INFO_V1(gbt_int8_penalty); +PG_FUNCTION_INFO_V1(gbt_int8_same); + + +static bool +gbt_int8gt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int64 *) a) > *((const int64 *) b)); +} +static bool +gbt_int8ge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int64 *) a) >= *((const int64 *) b)); +} +static bool +gbt_int8eq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int64 *) a) == *((const int64 *) b)); +} +static bool +gbt_int8le(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int64 *) a) <= *((const int64 *) b)); +} +static bool +gbt_int8lt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const int64 *) a) < *((const int64 *) b)); +} + +static int +gbt_int8key_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + int64KEY *ia = (int64KEY *) (((const Nsrt *) a)->t); + int64KEY *ib = (int64KEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + +static float8 +gbt_int8_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + return GET_FLOAT_DISTANCE(int64, a, b); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_int8, + sizeof(int64), + 16, /* sizeof(gbtreekey16) */ + gbt_int8gt, + gbt_int8ge, + gbt_int8eq, + gbt_int8le, + gbt_int8lt, + gbt_int8key_cmp, + gbt_int8_dist +}; + + +PG_FUNCTION_INFO_V1(int8_dist); +Datum +int8_dist(PG_FUNCTION_ARGS) +{ + int64 a = PG_GETARG_INT64(0); + int64 b = PG_GETARG_INT64(1); + int64 r; + int64 ra; + + if (pg_sub_s64_overflow(a, b, &r) || + r == PG_INT64_MIN) + ereport(ERROR, + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("bigint out of range"))); + + ra = Abs(r); + + PG_RETURN_INT64(ra); +} + + +/************************************************** + * int64 ops + **************************************************/ + + +Datum +gbt_int8_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_int8_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_int8_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int64 query = PG_GETARG_INT64(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + int64KEY *kkk = (int64KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int8_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int64 query = PG_GETARG_INT64(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + int64KEY *kkk = (int64KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int8_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(int64KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(int64KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_int8_penalty(PG_FUNCTION_ARGS) +{ + int64KEY *origentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + int64KEY *newentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_int8_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_int8_same(PG_FUNCTION_ARGS) +{ + int64KEY *b1 = (int64KEY *) PG_GETARG_POINTER(0); + int64KEY *b2 = (int64KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_interval.c b/contrib/btree_gist/btree_interval.c new file mode 100644 index 0000000..c2bf820 --- /dev/null +++ b/contrib/btree_gist/btree_interval.c @@ -0,0 +1,297 @@ +/* + * contrib/btree_gist/btree_interval.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/builtins.h" +#include "utils/timestamp.h" + +typedef struct +{ + Interval lower, + upper; +} intvKEY; + + +/* +** Interval ops +*/ +PG_FUNCTION_INFO_V1(gbt_intv_compress); +PG_FUNCTION_INFO_V1(gbt_intv_fetch); +PG_FUNCTION_INFO_V1(gbt_intv_decompress); +PG_FUNCTION_INFO_V1(gbt_intv_union); +PG_FUNCTION_INFO_V1(gbt_intv_picksplit); +PG_FUNCTION_INFO_V1(gbt_intv_consistent); +PG_FUNCTION_INFO_V1(gbt_intv_distance); +PG_FUNCTION_INFO_V1(gbt_intv_penalty); +PG_FUNCTION_INFO_V1(gbt_intv_same); + + +static bool +gbt_intvgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(interval_gt, IntervalPGetDatum(a), IntervalPGetDatum(b))); +} + +static bool +gbt_intvge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(interval_ge, IntervalPGetDatum(a), IntervalPGetDatum(b))); +} + +static bool +gbt_intveq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(interval_eq, IntervalPGetDatum(a), IntervalPGetDatum(b))); +} + +static bool +gbt_intvle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(interval_le, IntervalPGetDatum(a), IntervalPGetDatum(b))); +} + +static bool +gbt_intvlt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(interval_lt, IntervalPGetDatum(a), IntervalPGetDatum(b))); +} + +static int +gbt_intvkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + intvKEY *ia = (intvKEY *) (((const Nsrt *) a)->t); + intvKEY *ib = (intvKEY *) (((const Nsrt *) b)->t); + int res; + + res = DatumGetInt32(DirectFunctionCall2(interval_cmp, IntervalPGetDatum(&ia->lower), IntervalPGetDatum(&ib->lower))); + if (res == 0) + return DatumGetInt32(DirectFunctionCall2(interval_cmp, IntervalPGetDatum(&ia->upper), IntervalPGetDatum(&ib->upper))); + + return res; +} + + +static double +intr2num(const Interval *i) +{ + return INTERVAL_TO_SEC(i); +} + +static float8 +gbt_intv_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (float8) Abs(intr2num((const Interval *) a) - intr2num((const Interval *) b)); +} + +/* + * INTERVALSIZE should be the actual size-on-disk of an Interval, as shown + * in pg_type. This might be less than sizeof(Interval) if the compiler + * insists on adding alignment padding at the end of the struct. (Note: + * this concern is obsolete with the current definition of Interval, but + * was real before a separate "day" field was added to it.) + */ +#define INTERVALSIZE 16 + +static const gbtree_ninfo tinfo = +{ + gbt_t_intv, + sizeof(Interval), + 32, /* sizeof(gbtreekey32) */ + gbt_intvgt, + gbt_intvge, + gbt_intveq, + gbt_intvle, + gbt_intvlt, + gbt_intvkey_cmp, + gbt_intv_dist +}; + + +Interval * +abs_interval(Interval *a) +{ + static Interval zero = {0, 0, 0}; + + if (DatumGetBool(DirectFunctionCall2(interval_lt, + IntervalPGetDatum(a), + IntervalPGetDatum(&zero)))) + a = DatumGetIntervalP(DirectFunctionCall1(interval_um, + IntervalPGetDatum(a))); + + return a; +} + +PG_FUNCTION_INFO_V1(interval_dist); +Datum +interval_dist(PG_FUNCTION_ARGS) +{ + Datum diff = DirectFunctionCall2(interval_mi, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1)); + + PG_RETURN_INTERVAL_P(abs_interval(DatumGetIntervalP(diff))); +} + + +/************************************************** + * interval ops + **************************************************/ + + +Datum +gbt_intv_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = entry; + + if (entry->leafkey || INTERVALSIZE != sizeof(Interval)) + { + char *r = (char *) palloc(2 * INTERVALSIZE); + + retval = palloc(sizeof(GISTENTRY)); + + if (entry->leafkey) + { + Interval *key = DatumGetIntervalP(entry->key); + + memcpy((void *) r, (void *) key, INTERVALSIZE); + memcpy((void *) (r + INTERVALSIZE), (void *) key, INTERVALSIZE); + } + else + { + intvKEY *key = (intvKEY *) DatumGetPointer(entry->key); + + memcpy(r, &key->lower, INTERVALSIZE); + memcpy(r + INTERVALSIZE, &key->upper, INTERVALSIZE); + } + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, false); + } + + PG_RETURN_POINTER(retval); +} + +Datum +gbt_intv_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_intv_decompress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval = entry; + + if (INTERVALSIZE != sizeof(Interval)) + { + intvKEY *r = palloc(sizeof(intvKEY)); + char *key = DatumGetPointer(entry->key); + + retval = palloc(sizeof(GISTENTRY)); + memcpy(&r->lower, key, INTERVALSIZE); + memcpy(&r->upper, key + INTERVALSIZE, INTERVALSIZE); + + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, false); + } + PG_RETURN_POINTER(retval); +} + + +Datum +gbt_intv_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Interval *query = PG_GETARG_INTERVAL_P(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_intv_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Interval *query = PG_GETARG_INTERVAL_P(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_intv_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(intvKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(intvKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_intv_penalty(PG_FUNCTION_ARGS) +{ + intvKEY *origentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + intvKEY *newentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + double iorg[2], + inew[2]; + + iorg[0] = intr2num(&origentry->lower); + iorg[1] = intr2num(&origentry->upper); + inew[0] = intr2num(&newentry->lower); + inew[1] = intr2num(&newentry->upper); + + penalty_num(result, iorg[0], iorg[1], inew[0], inew[1]); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_intv_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_intv_same(PG_FUNCTION_ARGS) +{ + intvKEY *b1 = (intvKEY *) PG_GETARG_POINTER(0); + intvKEY *b2 = (intvKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_macaddr.c b/contrib/btree_gist/btree_macaddr.c new file mode 100644 index 0000000..1729052 --- /dev/null +++ b/contrib/btree_gist/btree_macaddr.c @@ -0,0 +1,196 @@ +/* + * contrib/btree_gist/btree_macaddr.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/builtins.h" +#include "utils/inet.h" + +typedef struct +{ + macaddr lower; + macaddr upper; + char pad[4]; /* make struct size = sizeof(gbtreekey16) */ +} macKEY; + +/* +** OID ops +*/ +PG_FUNCTION_INFO_V1(gbt_macad_compress); +PG_FUNCTION_INFO_V1(gbt_macad_fetch); +PG_FUNCTION_INFO_V1(gbt_macad_union); +PG_FUNCTION_INFO_V1(gbt_macad_picksplit); +PG_FUNCTION_INFO_V1(gbt_macad_consistent); +PG_FUNCTION_INFO_V1(gbt_macad_penalty); +PG_FUNCTION_INFO_V1(gbt_macad_same); + + +static bool +gbt_macadgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr_gt, PointerGetDatum(a), PointerGetDatum(b))); +} +static bool +gbt_macadge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr_ge, PointerGetDatum(a), PointerGetDatum(b))); +} + +static bool +gbt_macadeq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr_eq, PointerGetDatum(a), PointerGetDatum(b))); +} + +static bool +gbt_macadle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr_le, PointerGetDatum(a), PointerGetDatum(b))); +} + +static bool +gbt_macadlt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr_lt, PointerGetDatum(a), PointerGetDatum(b))); +} + + +static int +gbt_macadkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + macKEY *ia = (macKEY *) (((const Nsrt *) a)->t); + macKEY *ib = (macKEY *) (((const Nsrt *) b)->t); + int res; + + res = DatumGetInt32(DirectFunctionCall2(macaddr_cmp, MacaddrPGetDatum(&ia->lower), MacaddrPGetDatum(&ib->lower))); + if (res == 0) + return DatumGetInt32(DirectFunctionCall2(macaddr_cmp, MacaddrPGetDatum(&ia->upper), MacaddrPGetDatum(&ib->upper))); + + return res; +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_macad, + sizeof(macaddr), + 16, /* sizeof(gbtreekey16) */ + gbt_macadgt, + gbt_macadge, + gbt_macadeq, + gbt_macadle, + gbt_macadlt, + gbt_macadkey_cmp, + NULL +}; + + +/************************************************** + * macaddr ops + **************************************************/ + + + +static uint64 +mac_2_uint64(macaddr *m) +{ + unsigned char *mi = (unsigned char *) m; + uint64 res = 0; + int i; + + for (i = 0; i < 6; i++) + res += (((uint64) mi[i]) << ((uint64) ((5 - i) * 8))); + return res; +} + + + +Datum +gbt_macad_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_macad_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_macad_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + macaddr *query = (macaddr *) PG_GETARG_POINTER(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + macKEY *kkk = (macKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_macad_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc0(sizeof(macKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(macKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_macad_penalty(PG_FUNCTION_ARGS) +{ + macKEY *origentry = (macKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + macKEY *newentry = (macKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + uint64 iorg[2], + inew[2]; + + iorg[0] = mac_2_uint64(&origentry->lower); + iorg[1] = mac_2_uint64(&origentry->upper); + inew[0] = mac_2_uint64(&newentry->lower); + inew[1] = mac_2_uint64(&newentry->upper); + + penalty_num(result, iorg[0], iorg[1], inew[0], inew[1]); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_macad_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_macad_same(PG_FUNCTION_ARGS) +{ + macKEY *b1 = (macKEY *) PG_GETARG_POINTER(0); + macKEY *b2 = (macKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_macaddr8.c b/contrib/btree_gist/btree_macaddr8.c new file mode 100644 index 0000000..796cc4e --- /dev/null +++ b/contrib/btree_gist/btree_macaddr8.c @@ -0,0 +1,196 @@ +/* + * contrib/btree_gist/btree_macaddr8.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/builtins.h" +#include "utils/inet.h" + +typedef struct +{ + macaddr8 lower; + macaddr8 upper; + /* make struct size = sizeof(gbtreekey16) */ +} mac8KEY; + +/* +** OID ops +*/ +PG_FUNCTION_INFO_V1(gbt_macad8_compress); +PG_FUNCTION_INFO_V1(gbt_macad8_fetch); +PG_FUNCTION_INFO_V1(gbt_macad8_union); +PG_FUNCTION_INFO_V1(gbt_macad8_picksplit); +PG_FUNCTION_INFO_V1(gbt_macad8_consistent); +PG_FUNCTION_INFO_V1(gbt_macad8_penalty); +PG_FUNCTION_INFO_V1(gbt_macad8_same); + + +static bool +gbt_macad8gt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr8_gt, PointerGetDatum(a), PointerGetDatum(b))); +} +static bool +gbt_macad8ge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr8_ge, PointerGetDatum(a), PointerGetDatum(b))); +} + +static bool +gbt_macad8eq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr8_eq, PointerGetDatum(a), PointerGetDatum(b))); +} + +static bool +gbt_macad8le(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr8_le, PointerGetDatum(a), PointerGetDatum(b))); +} + +static bool +gbt_macad8lt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(macaddr8_lt, PointerGetDatum(a), PointerGetDatum(b))); +} + + +static int +gbt_macad8key_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + mac8KEY *ia = (mac8KEY *) (((const Nsrt *) a)->t); + mac8KEY *ib = (mac8KEY *) (((const Nsrt *) b)->t); + int res; + + res = DatumGetInt32(DirectFunctionCall2(macaddr8_cmp, Macaddr8PGetDatum(&ia->lower), Macaddr8PGetDatum(&ib->lower))); + if (res == 0) + return DatumGetInt32(DirectFunctionCall2(macaddr8_cmp, Macaddr8PGetDatum(&ia->upper), Macaddr8PGetDatum(&ib->upper))); + + return res; +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_macad8, + sizeof(macaddr8), + 16, /* sizeof(gbtreekey16) */ + gbt_macad8gt, + gbt_macad8ge, + gbt_macad8eq, + gbt_macad8le, + gbt_macad8lt, + gbt_macad8key_cmp, + NULL +}; + + +/************************************************** + * macaddr ops + **************************************************/ + + + +static uint64 +mac8_2_uint64(macaddr8 *m) +{ + unsigned char *mi = (unsigned char *) m; + uint64 res = 0; + int i; + + for (i = 0; i < 8; i++) + res += (((uint64) mi[i]) << ((uint64) ((7 - i) * 8))); + return res; +} + + + +Datum +gbt_macad8_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_macad8_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_macad8_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + macaddr8 *query = (macaddr8 *) PG_GETARG_POINTER(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + mac8KEY *kkk = (mac8KEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_macad8_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc0(sizeof(mac8KEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(mac8KEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_macad8_penalty(PG_FUNCTION_ARGS) +{ + mac8KEY *origentry = (mac8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + mac8KEY *newentry = (mac8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + uint64 iorg[2], + inew[2]; + + iorg[0] = mac8_2_uint64(&origentry->lower); + iorg[1] = mac8_2_uint64(&origentry->upper); + inew[0] = mac8_2_uint64(&newentry->lower); + inew[1] = mac8_2_uint64(&newentry->upper); + + penalty_num(result, iorg[0], iorg[1], inew[0], inew[1]); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_macad8_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_macad8_same(PG_FUNCTION_ARGS) +{ + mac8KEY *b1 = (mac8KEY *) PG_GETARG_POINTER(0); + mac8KEY *b2 = (mac8KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_numeric.c b/contrib/btree_gist/btree_numeric.c new file mode 100644 index 0000000..35e466c --- /dev/null +++ b/contrib/btree_gist/btree_numeric.c @@ -0,0 +1,229 @@ +/* + * contrib/btree_gist/btree_numeric.c + */ +#include "postgres.h" + +#include <math.h> +#include <float.h> + +#include "btree_gist.h" +#include "btree_utils_var.h" +#include "utils/builtins.h" +#include "utils/numeric.h" +#include "utils/rel.h" + +/* +** Bytea ops +*/ +PG_FUNCTION_INFO_V1(gbt_numeric_compress); +PG_FUNCTION_INFO_V1(gbt_numeric_union); +PG_FUNCTION_INFO_V1(gbt_numeric_picksplit); +PG_FUNCTION_INFO_V1(gbt_numeric_consistent); +PG_FUNCTION_INFO_V1(gbt_numeric_penalty); +PG_FUNCTION_INFO_V1(gbt_numeric_same); + + +/* define for comparison */ + +static bool +gbt_numeric_gt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(numeric_gt, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_numeric_ge(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(numeric_ge, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_numeric_eq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(numeric_eq, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_numeric_le(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(numeric_le, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_numeric_lt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2(numeric_lt, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static int32 +gbt_numeric_cmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetInt32(DirectFunctionCall2(numeric_cmp, + PointerGetDatum(a), + PointerGetDatum(b))); +} + + +static const gbtree_vinfo tinfo = +{ + gbt_t_numeric, + 0, + false, + gbt_numeric_gt, + gbt_numeric_ge, + gbt_numeric_eq, + gbt_numeric_le, + gbt_numeric_lt, + gbt_numeric_cmp, + NULL +}; + + +/************************************************** + * Text ops + **************************************************/ + + +Datum +gbt_numeric_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); +} + + + +Datum +gbt_numeric_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + void *query = (void *) DatumGetNumeric(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + bool retval; + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY_R r = gbt_var_key_readable(key); + + /* All cases served by this function are exact */ + *recheck = false; + + retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(), + GIST_LEAF(entry), &tinfo, fcinfo->flinfo); + PG_RETURN_BOOL(retval); +} + + + +Datum +gbt_numeric_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_numeric_same(PG_FUNCTION_ARGS) +{ + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} + + +Datum +gbt_numeric_penalty(PG_FUNCTION_ARGS) +{ + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); + + Numeric us, + os, + ds; + + GBT_VARKEY *org = (GBT_VARKEY *) DatumGetPointer(o->key); + GBT_VARKEY *newe = (GBT_VARKEY *) DatumGetPointer(n->key); + Datum uni; + GBT_VARKEY_R rk, + ok, + uk; + + rk = gbt_var_key_readable(org); + uni = PointerGetDatum(gbt_var_key_copy(&rk)); + gbt_var_bin_union(&uni, newe, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo); + ok = gbt_var_key_readable(org); + uk = gbt_var_key_readable((GBT_VARKEY *) DatumGetPointer(uni)); + + us = DatumGetNumeric(DirectFunctionCall2(numeric_sub, + PointerGetDatum(uk.upper), + PointerGetDatum(uk.lower))); + + os = DatumGetNumeric(DirectFunctionCall2(numeric_sub, + PointerGetDatum(ok.upper), + PointerGetDatum(ok.lower))); + + ds = DatumGetNumeric(DirectFunctionCall2(numeric_sub, + NumericGetDatum(us), + NumericGetDatum(os))); + + if (numeric_is_nan(us)) + { + if (numeric_is_nan(os)) + *result = 0.0; + else + *result = 1.0; + } + else + { + Numeric nul = int64_to_numeric(0); + + *result = 0.0; + + if (DirectFunctionCall2(numeric_gt, NumericGetDatum(ds), NumericGetDatum(nul))) + { + *result += FLT_MIN; + os = DatumGetNumeric(DirectFunctionCall2(numeric_div, + NumericGetDatum(ds), + NumericGetDatum(us))); + *result += (float4) DatumGetFloat8(DirectFunctionCall1(numeric_float8_no_overflow, NumericGetDatum(os))); + } + } + + if (*result > 0) + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + + PG_RETURN_POINTER(result); +} + + + +Datum +gbt_numeric_picksplit(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + + gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(v); +} diff --git a/contrib/btree_gist/btree_oid.c b/contrib/btree_gist/btree_oid.c new file mode 100644 index 0000000..3cc7d42 --- /dev/null +++ b/contrib/btree_gist/btree_oid.c @@ -0,0 +1,217 @@ +/* + * contrib/btree_gist/btree_oid.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" + +typedef struct +{ + Oid lower; + Oid upper; +} oidKEY; + +/* +** OID ops +*/ +PG_FUNCTION_INFO_V1(gbt_oid_compress); +PG_FUNCTION_INFO_V1(gbt_oid_fetch); +PG_FUNCTION_INFO_V1(gbt_oid_union); +PG_FUNCTION_INFO_V1(gbt_oid_picksplit); +PG_FUNCTION_INFO_V1(gbt_oid_consistent); +PG_FUNCTION_INFO_V1(gbt_oid_distance); +PG_FUNCTION_INFO_V1(gbt_oid_penalty); +PG_FUNCTION_INFO_V1(gbt_oid_same); + + +static bool +gbt_oidgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Oid *) a) > *((const Oid *) b)); +} +static bool +gbt_oidge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Oid *) a) >= *((const Oid *) b)); +} +static bool +gbt_oideq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Oid *) a) == *((const Oid *) b)); +} +static bool +gbt_oidle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Oid *) a) <= *((const Oid *) b)); +} +static bool +gbt_oidlt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return (*((const Oid *) a) < *((const Oid *) b)); +} + +static int +gbt_oidkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + oidKEY *ia = (oidKEY *) (((const Nsrt *) a)->t); + oidKEY *ib = (oidKEY *) (((const Nsrt *) b)->t); + + if (ia->lower == ib->lower) + { + if (ia->upper == ib->upper) + return 0; + + return (ia->upper > ib->upper) ? 1 : -1; + } + + return (ia->lower > ib->lower) ? 1 : -1; +} + +static float8 +gbt_oid_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + Oid aa = *(const Oid *) a; + Oid bb = *(const Oid *) b; + + if (aa < bb) + return (float8) (bb - aa); + else + return (float8) (aa - bb); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_oid, + sizeof(Oid), + 8, /* sizeof(gbtreekey8) */ + gbt_oidgt, + gbt_oidge, + gbt_oideq, + gbt_oidle, + gbt_oidlt, + gbt_oidkey_cmp, + gbt_oid_dist +}; + + +PG_FUNCTION_INFO_V1(oid_dist); +Datum +oid_dist(PG_FUNCTION_ARGS) +{ + Oid a = PG_GETARG_OID(0); + Oid b = PG_GETARG_OID(1); + Oid res; + + if (a < b) + res = b - a; + else + res = a - b; + PG_RETURN_OID(res); +} + + +/************************************************** + * Oid ops + **************************************************/ + + +Datum +gbt_oid_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + +Datum +gbt_oid_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_oid_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Oid query = PG_GETARG_OID(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + oidKEY *kkk = (oidKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_oid_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Oid query = PG_GETARG_OID(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + oidKEY *kkk = (oidKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_oid_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(oidKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(oidKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_oid_penalty(PG_FUNCTION_ARGS) +{ + oidKEY *origentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + oidKEY *newentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_oid_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_oid_same(PG_FUNCTION_ARGS) +{ + oidKEY *b1 = (oidKEY *) PG_GETARG_POINTER(0); + oidKEY *b2 = (oidKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_text.c b/contrib/btree_gist/btree_text.c new file mode 100644 index 0000000..be0eac7 --- /dev/null +++ b/contrib/btree_gist/btree_text.c @@ -0,0 +1,289 @@ +/* + * contrib/btree_gist/btree_text.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_var.h" +#include "utils/builtins.h" + +/* +** Text ops +*/ +PG_FUNCTION_INFO_V1(gbt_text_compress); +PG_FUNCTION_INFO_V1(gbt_bpchar_compress); +PG_FUNCTION_INFO_V1(gbt_text_union); +PG_FUNCTION_INFO_V1(gbt_text_picksplit); +PG_FUNCTION_INFO_V1(gbt_text_consistent); +PG_FUNCTION_INFO_V1(gbt_bpchar_consistent); +PG_FUNCTION_INFO_V1(gbt_text_penalty); +PG_FUNCTION_INFO_V1(gbt_text_same); + + +/* define for comparison */ + +static bool +gbt_textgt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(text_gt, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_textge(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(text_ge, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_texteq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(texteq, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_textle(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(text_le, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_textlt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(text_lt, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static int32 +gbt_textcmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetInt32(DirectFunctionCall2Coll(bttextcmp, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static gbtree_vinfo tinfo = +{ + gbt_t_text, + 0, + false, + gbt_textgt, + gbt_textge, + gbt_texteq, + gbt_textle, + gbt_textlt, + gbt_textcmp, + NULL +}; + +/* bpchar needs its own comparison rules */ + +static bool +gbt_bpchargt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(bpchargt, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bpcharge(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(bpcharge, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bpchareq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(bpchareq, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bpcharle(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(bpcharle, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static bool +gbt_bpcharlt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetBool(DirectFunctionCall2Coll(bpcharlt, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static int32 +gbt_bpcharcmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo) +{ + return DatumGetInt32(DirectFunctionCall2Coll(bpcharcmp, + collation, + PointerGetDatum(a), + PointerGetDatum(b))); +} + +static gbtree_vinfo bptinfo = +{ + gbt_t_bpchar, + 0, + false, + gbt_bpchargt, + gbt_bpcharge, + gbt_bpchareq, + gbt_bpcharle, + gbt_bpcharlt, + gbt_bpcharcmp, + NULL +}; + + +/************************************************** + * Text ops + **************************************************/ + + +Datum +gbt_text_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + if (tinfo.eml == 0) + { + tinfo.eml = pg_database_encoding_max_length(); + } + + PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo)); +} + +Datum +gbt_bpchar_compress(PG_FUNCTION_ARGS) +{ + /* This should never have been distinct from gbt_text_compress */ + return gbt_text_compress(fcinfo); +} + + + +Datum +gbt_text_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + void *query = (void *) DatumGetTextP(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + bool retval; + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY_R r = gbt_var_key_readable(key); + + /* All cases served by this function are exact */ + *recheck = false; + + if (tinfo.eml == 0) + { + tinfo.eml = pg_database_encoding_max_length(); + } + + retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(), + GIST_LEAF(entry), &tinfo, fcinfo->flinfo); + + PG_RETURN_BOOL(retval); +} + + +Datum +gbt_bpchar_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + void *query = (void *) DatumGetTextP(PG_GETARG_DATUM(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + bool retval; + GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key); + GBT_VARKEY_R r = gbt_var_key_readable(key); + + /* All cases served by this function are exact */ + *recheck = false; + + if (bptinfo.eml == 0) + { + bptinfo.eml = pg_database_encoding_max_length(); + } + + retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(), + GIST_LEAF(entry), &bptinfo, fcinfo->flinfo); + PG_RETURN_BOOL(retval); +} + + +Datum +gbt_text_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int32 *size = (int *) PG_GETARG_POINTER(1); + + PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_text_picksplit(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + + gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(v); +} + +Datum +gbt_text_same(PG_FUNCTION_ARGS) +{ + Datum d1 = PG_GETARG_DATUM(0); + Datum d2 = PG_GETARG_DATUM(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} + + +Datum +gbt_text_penalty(PG_FUNCTION_ARGS) +{ + GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); + + PG_RETURN_POINTER(gbt_var_penalty(result, o, n, PG_GET_COLLATION(), + &tinfo, fcinfo->flinfo)); +} diff --git a/contrib/btree_gist/btree_time.c b/contrib/btree_gist/btree_time.c new file mode 100644 index 0000000..fd8774a --- /dev/null +++ b/contrib/btree_gist/btree_time.c @@ -0,0 +1,334 @@ +/* + * contrib/btree_gist/btree_time.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/builtins.h" +#include "utils/date.h" +#include "utils/timestamp.h" + +typedef struct +{ + TimeADT lower; + TimeADT upper; +} timeKEY; + +/* +** time ops +*/ +PG_FUNCTION_INFO_V1(gbt_time_compress); +PG_FUNCTION_INFO_V1(gbt_timetz_compress); +PG_FUNCTION_INFO_V1(gbt_time_fetch); +PG_FUNCTION_INFO_V1(gbt_time_union); +PG_FUNCTION_INFO_V1(gbt_time_picksplit); +PG_FUNCTION_INFO_V1(gbt_time_consistent); +PG_FUNCTION_INFO_V1(gbt_time_distance); +PG_FUNCTION_INFO_V1(gbt_timetz_consistent); +PG_FUNCTION_INFO_V1(gbt_time_penalty); +PG_FUNCTION_INFO_V1(gbt_time_same); + + +#ifdef USE_FLOAT8_BYVAL +#define TimeADTGetDatumFast(X) TimeADTGetDatum(X) +#else +#define TimeADTGetDatumFast(X) PointerGetDatum(&(X)) +#endif + + +static bool +gbt_timegt(const void *a, const void *b, FmgrInfo *flinfo) +{ + const TimeADT *aa = (const TimeADT *) a; + const TimeADT *bb = (const TimeADT *) b; + + return DatumGetBool(DirectFunctionCall2(time_gt, + TimeADTGetDatumFast(*aa), + TimeADTGetDatumFast(*bb))); +} + +static bool +gbt_timege(const void *a, const void *b, FmgrInfo *flinfo) +{ + const TimeADT *aa = (const TimeADT *) a; + const TimeADT *bb = (const TimeADT *) b; + + return DatumGetBool(DirectFunctionCall2(time_ge, + TimeADTGetDatumFast(*aa), + TimeADTGetDatumFast(*bb))); +} + +static bool +gbt_timeeq(const void *a, const void *b, FmgrInfo *flinfo) +{ + const TimeADT *aa = (const TimeADT *) a; + const TimeADT *bb = (const TimeADT *) b; + + return DatumGetBool(DirectFunctionCall2(time_eq, + TimeADTGetDatumFast(*aa), + TimeADTGetDatumFast(*bb))); +} + +static bool +gbt_timele(const void *a, const void *b, FmgrInfo *flinfo) +{ + const TimeADT *aa = (const TimeADT *) a; + const TimeADT *bb = (const TimeADT *) b; + + return DatumGetBool(DirectFunctionCall2(time_le, + TimeADTGetDatumFast(*aa), + TimeADTGetDatumFast(*bb))); +} + +static bool +gbt_timelt(const void *a, const void *b, FmgrInfo *flinfo) +{ + const TimeADT *aa = (const TimeADT *) a; + const TimeADT *bb = (const TimeADT *) b; + + return DatumGetBool(DirectFunctionCall2(time_lt, + TimeADTGetDatumFast(*aa), + TimeADTGetDatumFast(*bb))); +} + + + +static int +gbt_timekey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + timeKEY *ia = (timeKEY *) (((const Nsrt *) a)->t); + timeKEY *ib = (timeKEY *) (((const Nsrt *) b)->t); + int res; + + res = DatumGetInt32(DirectFunctionCall2(time_cmp, TimeADTGetDatumFast(ia->lower), TimeADTGetDatumFast(ib->lower))); + if (res == 0) + return DatumGetInt32(DirectFunctionCall2(time_cmp, TimeADTGetDatumFast(ia->upper), TimeADTGetDatumFast(ib->upper))); + + return res; +} + +static float8 +gbt_time_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + const TimeADT *aa = (const TimeADT *) a; + const TimeADT *bb = (const TimeADT *) b; + Interval *i; + + i = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, + TimeADTGetDatumFast(*aa), + TimeADTGetDatumFast(*bb))); + return (float8) Abs(INTERVAL_TO_SEC(i)); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_time, + sizeof(TimeADT), + 16, /* sizeof(gbtreekey16) */ + gbt_timegt, + gbt_timege, + gbt_timeeq, + gbt_timele, + gbt_timelt, + gbt_timekey_cmp, + gbt_time_dist +}; + + +PG_FUNCTION_INFO_V1(time_dist); +Datum +time_dist(PG_FUNCTION_ARGS) +{ + Datum diff = DirectFunctionCall2(time_mi_time, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1)); + + PG_RETURN_INTERVAL_P(abs_interval(DatumGetIntervalP(diff))); +} + + +/************************************************** + * time ops + **************************************************/ + + + +Datum +gbt_time_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + + +Datum +gbt_timetz_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; + + if (entry->leafkey) + { + timeKEY *r = (timeKEY *) palloc(sizeof(timeKEY)); + TimeTzADT *tz = DatumGetTimeTzADTP(entry->key); + TimeADT tmp; + + retval = palloc(sizeof(GISTENTRY)); + + /* We are using the time + zone only to compress */ + tmp = tz->time + (tz->zone * INT64CONST(1000000)); + r->lower = r->upper = tmp; + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, false); + } + else + retval = entry; + PG_RETURN_POINTER(retval); +} + +Datum +gbt_time_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_time_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimeADT query = PG_GETARG_TIMEADT(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_time_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimeADT query = PG_GETARG_TIMEADT(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_timetz_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimeTzADT *query = PG_GETARG_TIMETZADT_P(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key); + TimeADT qqq; + GBT_NUMKEY_R key; + + /* All cases served by this function are inexact */ + *recheck = true; + + qqq = query->time + (query->zone * INT64CONST(1000000)); + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &qqq, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_time_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(timeKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(timeKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_time_penalty(PG_FUNCTION_ARGS) +{ + timeKEY *origentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + timeKEY *newentry = (timeKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + Interval *intr; + double res; + double res2; + + intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, + TimeADTGetDatumFast(newentry->upper), + TimeADTGetDatumFast(origentry->upper))); + res = INTERVAL_TO_SEC(intr); + res = Max(res, 0); + + intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, + TimeADTGetDatumFast(origentry->lower), + TimeADTGetDatumFast(newentry->lower))); + res2 = INTERVAL_TO_SEC(intr); + res2 = Max(res2, 0); + + res += res2; + + *result = 0.0; + + if (res > 0) + { + intr = DatumGetIntervalP(DirectFunctionCall2(time_mi_time, + TimeADTGetDatumFast(origentry->upper), + TimeADTGetDatumFast(origentry->lower))); + *result += FLT_MIN; + *result += (float) (res / (res + INTERVAL_TO_SEC(intr))); + *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); + } + + PG_RETURN_POINTER(result); +} + + +Datum +gbt_time_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_time_same(PG_FUNCTION_ARGS) +{ + timeKEY *b1 = (timeKEY *) PG_GETARG_POINTER(0); + timeKEY *b2 = (timeKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_ts.c b/contrib/btree_gist/btree_ts.c new file mode 100644 index 0000000..a519009 --- /dev/null +++ b/contrib/btree_gist/btree_ts.c @@ -0,0 +1,400 @@ +/* + * contrib/btree_gist/btree_ts.c + */ +#include "postgres.h" + +#include <limits.h> + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/builtins.h" +#include "utils/datetime.h" +#include "utils/float.h" + +typedef struct +{ + Timestamp lower; + Timestamp upper; +} tsKEY; + +/* +** timestamp ops +*/ +PG_FUNCTION_INFO_V1(gbt_ts_compress); +PG_FUNCTION_INFO_V1(gbt_tstz_compress); +PG_FUNCTION_INFO_V1(gbt_ts_fetch); +PG_FUNCTION_INFO_V1(gbt_ts_union); +PG_FUNCTION_INFO_V1(gbt_ts_picksplit); +PG_FUNCTION_INFO_V1(gbt_ts_consistent); +PG_FUNCTION_INFO_V1(gbt_ts_distance); +PG_FUNCTION_INFO_V1(gbt_tstz_consistent); +PG_FUNCTION_INFO_V1(gbt_tstz_distance); +PG_FUNCTION_INFO_V1(gbt_ts_penalty); +PG_FUNCTION_INFO_V1(gbt_ts_same); + + +#ifdef USE_FLOAT8_BYVAL +#define TimestampGetDatumFast(X) TimestampGetDatum(X) +#else +#define TimestampGetDatumFast(X) PointerGetDatum(&(X)) +#endif + + +static bool +gbt_tsgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + const Timestamp *aa = (const Timestamp *) a; + const Timestamp *bb = (const Timestamp *) b; + + return DatumGetBool(DirectFunctionCall2(timestamp_gt, + TimestampGetDatumFast(*aa), + TimestampGetDatumFast(*bb))); +} + +static bool +gbt_tsge(const void *a, const void *b, FmgrInfo *flinfo) +{ + const Timestamp *aa = (const Timestamp *) a; + const Timestamp *bb = (const Timestamp *) b; + + return DatumGetBool(DirectFunctionCall2(timestamp_ge, + TimestampGetDatumFast(*aa), + TimestampGetDatumFast(*bb))); +} + +static bool +gbt_tseq(const void *a, const void *b, FmgrInfo *flinfo) +{ + const Timestamp *aa = (const Timestamp *) a; + const Timestamp *bb = (const Timestamp *) b; + + return DatumGetBool(DirectFunctionCall2(timestamp_eq, + TimestampGetDatumFast(*aa), + TimestampGetDatumFast(*bb))); +} + +static bool +gbt_tsle(const void *a, const void *b, FmgrInfo *flinfo) +{ + const Timestamp *aa = (const Timestamp *) a; + const Timestamp *bb = (const Timestamp *) b; + + return DatumGetBool(DirectFunctionCall2(timestamp_le, + TimestampGetDatumFast(*aa), + TimestampGetDatumFast(*bb))); +} + +static bool +gbt_tslt(const void *a, const void *b, FmgrInfo *flinfo) +{ + const Timestamp *aa = (const Timestamp *) a; + const Timestamp *bb = (const Timestamp *) b; + + return DatumGetBool(DirectFunctionCall2(timestamp_lt, + TimestampGetDatumFast(*aa), + TimestampGetDatumFast(*bb))); +} + + +static int +gbt_tskey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + tsKEY *ia = (tsKEY *) (((const Nsrt *) a)->t); + tsKEY *ib = (tsKEY *) (((const Nsrt *) b)->t); + int res; + + res = DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatumFast(ia->lower), TimestampGetDatumFast(ib->lower))); + if (res == 0) + return DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatumFast(ia->upper), TimestampGetDatumFast(ib->upper))); + + return res; +} + +static float8 +gbt_ts_dist(const void *a, const void *b, FmgrInfo *flinfo) +{ + const Timestamp *aa = (const Timestamp *) a; + const Timestamp *bb = (const Timestamp *) b; + Interval *i; + + if (TIMESTAMP_NOT_FINITE(*aa) || TIMESTAMP_NOT_FINITE(*bb)) + return get_float8_infinity(); + + i = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi, + TimestampGetDatumFast(*aa), + TimestampGetDatumFast(*bb))); + return (float8) Abs(INTERVAL_TO_SEC(i)); +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_ts, + sizeof(Timestamp), + 16, /* sizeof(gbtreekey16) */ + gbt_tsgt, + gbt_tsge, + gbt_tseq, + gbt_tsle, + gbt_tslt, + gbt_tskey_cmp, + gbt_ts_dist +}; + + +PG_FUNCTION_INFO_V1(ts_dist); +Datum +ts_dist(PG_FUNCTION_ARGS) +{ + Timestamp a = PG_GETARG_TIMESTAMP(0); + Timestamp b = PG_GETARG_TIMESTAMP(1); + Interval *r; + + if (TIMESTAMP_NOT_FINITE(a) || TIMESTAMP_NOT_FINITE(b)) + { + Interval *p = palloc(sizeof(Interval)); + + p->day = INT_MAX; + p->month = INT_MAX; + p->time = PG_INT64_MAX; + PG_RETURN_INTERVAL_P(p); + } + else + r = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + PG_RETURN_INTERVAL_P(abs_interval(r)); +} + +PG_FUNCTION_INFO_V1(tstz_dist); +Datum +tstz_dist(PG_FUNCTION_ARGS) +{ + TimestampTz a = PG_GETARG_TIMESTAMPTZ(0); + TimestampTz b = PG_GETARG_TIMESTAMPTZ(1); + Interval *r; + + if (TIMESTAMP_NOT_FINITE(a) || TIMESTAMP_NOT_FINITE(b)) + { + Interval *p = palloc(sizeof(Interval)); + + p->day = INT_MAX; + p->month = INT_MAX; + p->time = PG_INT64_MAX; + PG_RETURN_INTERVAL_P(p); + } + + r = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + PG_RETURN_INTERVAL_P(abs_interval(r)); +} + + +/************************************************** + * timestamp ops + **************************************************/ + + +static inline Timestamp +tstz_to_ts_gmt(TimestampTz ts) +{ + /* No timezone correction is needed, since GMT is offset 0 by definition */ + return (Timestamp) ts; +} + + +Datum +gbt_ts_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo)); +} + + +Datum +gbt_tstz_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; + + if (entry->leafkey) + { + tsKEY *r = (tsKEY *) palloc(sizeof(tsKEY)); + TimestampTz ts = DatumGetTimestampTz(entry->key); + Timestamp gmt; + + gmt = tstz_to_ts_gmt(ts); + + retval = palloc(sizeof(GISTENTRY)); + r->lower = r->upper = gmt; + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, false); + } + else + retval = entry; + + PG_RETURN_POINTER(retval); +} + +Datum +gbt_ts_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_ts_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Timestamp query = PG_GETARG_TIMESTAMP(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_ts_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Timestamp query = PG_GETARG_TIMESTAMP(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_tstz_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimestampTz query = PG_GETARG_TIMESTAMPTZ(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + char *kkk = (char *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + Timestamp qqq; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk[0]; + key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)]; + qqq = tstz_to_ts_gmt(query); + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &qqq, &strategy, + GIST_LEAF(entry), &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_tstz_distance(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + TimestampTz query = PG_GETARG_TIMESTAMPTZ(1); + + /* Oid subtype = PG_GETARG_OID(3); */ + char *kkk = (char *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + Timestamp qqq; + + key.lower = (GBT_NUMKEY *) &kkk[0]; + key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)]; + qqq = tstz_to_ts_gmt(query); + + PG_RETURN_FLOAT8(gbt_num_distance(&key, (void *) &qqq, GIST_LEAF(entry), + &tinfo, fcinfo->flinfo)); +} + + +Datum +gbt_ts_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(tsKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + + +#define penalty_check_max_float(val) \ + do { \ + if ( val > FLT_MAX ) \ + val = FLT_MAX; \ + if ( val < -FLT_MAX ) \ + val = -FLT_MAX; \ + } while (0) + + +Datum +gbt_ts_penalty(PG_FUNCTION_ARGS) +{ + tsKEY *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + tsKEY *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + double orgdbl[2], + newdbl[2]; + + /* + * We are always using "double" timestamps here. Precision should be good + * enough. + */ + orgdbl[0] = ((double) origentry->lower); + orgdbl[1] = ((double) origentry->upper); + newdbl[0] = ((double) newentry->lower); + newdbl[1] = ((double) newentry->upper); + + penalty_check_max_float(orgdbl[0]); + penalty_check_max_float(orgdbl[1]); + penalty_check_max_float(newdbl[0]); + penalty_check_max_float(newdbl[1]); + + penalty_num(result, orgdbl[0], orgdbl[1], newdbl[0], newdbl[1]); + + PG_RETURN_POINTER(result); +} + + +Datum +gbt_ts_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_ts_same(PG_FUNCTION_ARGS) +{ + tsKEY *b1 = (tsKEY *) PG_GETARG_POINTER(0); + tsKEY *b2 = (tsKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/btree_utils_num.c b/contrib/btree_gist/btree_utils_num.c new file mode 100644 index 0000000..5632ee0 --- /dev/null +++ b/contrib/btree_gist/btree_utils_num.c @@ -0,0 +1,384 @@ +/* + * contrib/btree_gist/btree_utils_num.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "utils/cash.h" +#include "utils/date.h" +#include "utils/timestamp.h" + + +GISTENTRY * +gbt_num_compress(GISTENTRY *entry, const gbtree_ninfo *tinfo) +{ + GISTENTRY *retval; + + if (entry->leafkey) + { + union + { + bool bo; + int16 i2; + int32 i4; + int64 i8; + float4 f4; + float8 f8; + DateADT dt; + TimeADT tm; + Timestamp ts; + Cash ch; + } v; + + GBT_NUMKEY *r = (GBT_NUMKEY *) palloc0(tinfo->indexsize); + void *leaf = NULL; + + switch (tinfo->t) + { + case gbt_t_bool: + v.bo = DatumGetBool(entry->key); + leaf = &v.bo; + break; + case gbt_t_int2: + v.i2 = DatumGetInt16(entry->key); + leaf = &v.i2; + break; + case gbt_t_int4: + v.i4 = DatumGetInt32(entry->key); + leaf = &v.i4; + break; + case gbt_t_int8: + v.i8 = DatumGetInt64(entry->key); + leaf = &v.i8; + break; + case gbt_t_oid: + case gbt_t_enum: + v.i4 = DatumGetObjectId(entry->key); + leaf = &v.i4; + break; + case gbt_t_float4: + v.f4 = DatumGetFloat4(entry->key); + leaf = &v.f4; + break; + case gbt_t_float8: + v.f8 = DatumGetFloat8(entry->key); + leaf = &v.f8; + break; + case gbt_t_date: + v.dt = DatumGetDateADT(entry->key); + leaf = &v.dt; + break; + case gbt_t_time: + v.tm = DatumGetTimeADT(entry->key); + leaf = &v.tm; + break; + case gbt_t_ts: + v.ts = DatumGetTimestamp(entry->key); + leaf = &v.ts; + break; + case gbt_t_cash: + v.ch = DatumGetCash(entry->key); + leaf = &v.ch; + break; + default: + leaf = DatumGetPointer(entry->key); + } + + Assert(tinfo->indexsize >= 2 * tinfo->size); + + memcpy((void *) &r[0], leaf, tinfo->size); + memcpy((void *) &r[tinfo->size], leaf, tinfo->size); + retval = palloc(sizeof(GISTENTRY)); + gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, + entry->offset, false); + } + else + retval = entry; + + return retval; +} + +/* + * Convert a compressed leaf item back to the original type, for index-only + * scans. + */ +GISTENTRY * +gbt_num_fetch(GISTENTRY *entry, const gbtree_ninfo *tinfo) +{ + GISTENTRY *retval; + Datum datum; + + Assert(tinfo->indexsize >= 2 * tinfo->size); + + /* + * Get the original Datum from the stored datum. On leaf entries, the + * lower and upper bound are the same. We just grab the lower bound and + * return it. + */ + switch (tinfo->t) + { + case gbt_t_bool: + datum = BoolGetDatum(*(bool *) entry->key); + break; + case gbt_t_int2: + datum = Int16GetDatum(*(int16 *) entry->key); + break; + case gbt_t_int4: + datum = Int32GetDatum(*(int32 *) entry->key); + break; + case gbt_t_int8: + datum = Int64GetDatum(*(int64 *) entry->key); + break; + case gbt_t_oid: + case gbt_t_enum: + datum = ObjectIdGetDatum(*(Oid *) entry->key); + break; + case gbt_t_float4: + datum = Float4GetDatum(*(float4 *) entry->key); + break; + case gbt_t_float8: + datum = Float8GetDatum(*(float8 *) entry->key); + break; + case gbt_t_date: + datum = DateADTGetDatum(*(DateADT *) entry->key); + break; + case gbt_t_time: + datum = TimeADTGetDatum(*(TimeADT *) entry->key); + break; + case gbt_t_ts: + datum = TimestampGetDatum(*(Timestamp *) entry->key); + break; + case gbt_t_cash: + datum = CashGetDatum(*(Cash *) entry->key); + break; + default: + datum = PointerGetDatum(entry->key); + } + + retval = palloc(sizeof(GISTENTRY)); + gistentryinit(*retval, datum, entry->rel, entry->page, entry->offset, + false); + return retval; +} + + + +/* +** The GiST union method for numerical values +*/ + +void * +gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo, FmgrInfo *flinfo) +{ + int i, + numranges; + GBT_NUMKEY *cur; + GBT_NUMKEY_R o, + c; + + numranges = entryvec->n; + cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[0].key)); + + + o.lower = &((GBT_NUMKEY *) out)[0]; + o.upper = &((GBT_NUMKEY *) out)[tinfo->size]; + + memcpy((void *) out, (void *) cur, 2 * tinfo->size); + + for (i = 1; i < numranges; i++) + { + cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key)); + c.lower = &cur[0]; + c.upper = &cur[tinfo->size]; + /* if out->lower > cur->lower, adopt cur as lower */ + if (tinfo->f_gt(o.lower, c.lower, flinfo)) + memcpy(unconstify(GBT_NUMKEY *, o.lower), c.lower, tinfo->size); + /* if out->upper < cur->upper, adopt cur as upper */ + if (tinfo->f_lt(o.upper, c.upper, flinfo)) + memcpy(unconstify(GBT_NUMKEY *, o.upper), c.upper, tinfo->size); + } + + return out; +} + + + +/* +** The GiST same method for numerical values +*/ + +bool +gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo, FmgrInfo *flinfo) +{ + GBT_NUMKEY_R b1, + b2; + + b1.lower = &(a[0]); + b1.upper = &(a[tinfo->size]); + b2.lower = &(b[0]); + b2.upper = &(b[tinfo->size]); + + return (tinfo->f_eq(b1.lower, b2.lower, flinfo) && + tinfo->f_eq(b1.upper, b2.upper, flinfo)); +} + + +void +gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo, FmgrInfo *flinfo) +{ + GBT_NUMKEY_R rd; + + rd.lower = &e[0]; + rd.upper = &e[tinfo->size]; + + if (!DatumGetPointer(*u)) + { + *u = PointerGetDatum(palloc0(tinfo->indexsize)); + memcpy(&(((GBT_NUMKEY *) DatumGetPointer(*u))[0]), rd.lower, tinfo->size); + memcpy(&(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]), rd.upper, tinfo->size); + } + else + { + GBT_NUMKEY_R ur; + + ur.lower = &(((GBT_NUMKEY *) DatumGetPointer(*u))[0]); + ur.upper = &(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]); + if (tinfo->f_gt(ur.lower, rd.lower, flinfo)) + memcpy(unconstify(GBT_NUMKEY *, ur.lower), rd.lower, tinfo->size); + if (tinfo->f_lt(ur.upper, rd.upper, flinfo)) + memcpy(unconstify(GBT_NUMKEY *, ur.upper), rd.upper, tinfo->size); + } +} + + + +/* + * The GiST consistent method + * + * Note: we currently assume that no datatypes that use this routine are + * collation-aware; so we don't bother passing collation through. + */ +bool +gbt_num_consistent(const GBT_NUMKEY_R *key, + const void *query, + const StrategyNumber *strategy, + bool is_leaf, + const gbtree_ninfo *tinfo, + FmgrInfo *flinfo) +{ + bool retval; + + switch (*strategy) + { + case BTLessEqualStrategyNumber: + retval = tinfo->f_ge(query, key->lower, flinfo); + break; + case BTLessStrategyNumber: + if (is_leaf) + retval = tinfo->f_gt(query, key->lower, flinfo); + else + retval = tinfo->f_ge(query, key->lower, flinfo); + break; + case BTEqualStrategyNumber: + if (is_leaf) + retval = tinfo->f_eq(query, key->lower, flinfo); + else + retval = (tinfo->f_le(key->lower, query, flinfo) && + tinfo->f_le(query, key->upper, flinfo)); + break; + case BTGreaterStrategyNumber: + if (is_leaf) + retval = tinfo->f_lt(query, key->upper, flinfo); + else + retval = tinfo->f_le(query, key->upper, flinfo); + break; + case BTGreaterEqualStrategyNumber: + retval = tinfo->f_le(query, key->upper, flinfo); + break; + case BtreeGistNotEqualStrategyNumber: + retval = (!(tinfo->f_eq(query, key->lower, flinfo) && + tinfo->f_eq(query, key->upper, flinfo))); + break; + default: + retval = false; + } + + return retval; +} + + +/* +** The GiST distance method (for KNN-Gist) +*/ + +float8 +gbt_num_distance(const GBT_NUMKEY_R *key, + const void *query, + bool is_leaf, + const gbtree_ninfo *tinfo, + FmgrInfo *flinfo) +{ + float8 retval; + + if (tinfo->f_dist == NULL) + elog(ERROR, "KNN search is not supported for btree_gist type %d", + (int) tinfo->t); + if (tinfo->f_le(query, key->lower, flinfo)) + retval = tinfo->f_dist(query, key->lower, flinfo); + else if (tinfo->f_ge(query, key->upper, flinfo)) + retval = tinfo->f_dist(query, key->upper, flinfo); + else + retval = 0.0; + + return retval; +} + + +GIST_SPLITVEC * +gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, + const gbtree_ninfo *tinfo, FmgrInfo *flinfo) +{ + OffsetNumber i, + maxoff = entryvec->n - 1; + Nsrt *arr; + int nbytes; + + arr = (Nsrt *) palloc((maxoff + 1) * sizeof(Nsrt)); + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + v->spl_ldatum = PointerGetDatum(0); + v->spl_rdatum = PointerGetDatum(0); + v->spl_nleft = 0; + v->spl_nright = 0; + + /* Sort entries */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + arr[i].t = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key)); + arr[i].i = i; + } + qsort_arg((void *) &arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), (qsort_arg_comparator) tinfo->f_cmp, (void *) flinfo); + + /* We do simply create two parts */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + if (i <= (maxoff - FirstOffsetNumber + 1) / 2) + { + gbt_num_bin_union(&v->spl_ldatum, arr[i].t, tinfo, flinfo); + v->spl_left[v->spl_nleft] = arr[i].i; + v->spl_nleft++; + } + else + { + gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo, flinfo); + v->spl_right[v->spl_nright] = arr[i].i; + v->spl_nright++; + } + } + + return v; +} diff --git a/contrib/btree_gist/btree_utils_num.h b/contrib/btree_gist/btree_utils_num.h new file mode 100644 index 0000000..415a7a6 --- /dev/null +++ b/contrib/btree_gist/btree_utils_num.h @@ -0,0 +1,118 @@ +/* + * contrib/btree_gist/btree_utils_num.h + */ +#ifndef __BTREE_UTILS_NUM_H__ +#define __BTREE_UTILS_NUM_H__ + +#include <math.h> +#include <float.h> + +#include "access/gist.h" +#include "btree_gist.h" +#include "utils/rel.h" + +typedef char GBT_NUMKEY; + +/* Better readable key */ +typedef struct +{ + const GBT_NUMKEY *lower, + *upper; +} GBT_NUMKEY_R; + + +/* for sorting */ +typedef struct +{ + int i; + GBT_NUMKEY *t; +} Nsrt; + + +/* type description */ + +typedef struct +{ + + /* Attribs */ + + enum gbtree_type t; /* data type */ + int32 size; /* size of type, 0 means variable */ + int32 indexsize; /* size of datums stored in index */ + + /* Methods */ + + bool (*f_gt) (const void *, const void *, FmgrInfo *); /* greater than */ + bool (*f_ge) (const void *, const void *, FmgrInfo *); /* greater or equal */ + bool (*f_eq) (const void *, const void *, FmgrInfo *); /* equal */ + bool (*f_le) (const void *, const void *, FmgrInfo *); /* less or equal */ + bool (*f_lt) (const void *, const void *, FmgrInfo *); /* less than */ + int (*f_cmp) (const void *, const void *, FmgrInfo *); /* key compare function */ + float8 (*f_dist) (const void *, const void *, FmgrInfo *); /* key distance function */ +} gbtree_ninfo; + + +/* + * Numeric btree functions + */ + + + +/* + * Note: The factor 0.49 in following macro avoids floating point overflows + */ +#define penalty_num(result,olower,oupper,nlower,nupper) do { \ + double tmp = 0.0F; \ + (*(result)) = 0.0F; \ + if ( (nupper) > (oupper) ) \ + tmp += ( ((double)nupper)*0.49F - ((double)oupper)*0.49F ); \ + if ( (olower) > (nlower) ) \ + tmp += ( ((double)olower)*0.49F - ((double)nlower)*0.49F ); \ + if (tmp > 0.0F) \ + { \ + (*(result)) += FLT_MIN; \ + (*(result)) += (float) ( ((double)(tmp)) / ( (double)(tmp) + ( ((double)(oupper))*0.49F - ((double)(olower))*0.49F ) ) ); \ + (*(result)) *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); \ + } \ +} while (0) + + +/* + * Convert an Interval to an approximate equivalent number of seconds + * (as a double). Here because we need it for time/timetz as well as + * interval. See interval_cmp_internal for comparison. + */ +#define INTERVAL_TO_SEC(ivp) \ + (((double) (ivp)->time) / ((double) USECS_PER_SEC) + \ + (ivp)->day * (24.0 * SECS_PER_HOUR) + \ + (ivp)->month * (30.0 * SECS_PER_DAY)) + +#define GET_FLOAT_DISTANCE(t, arg1, arg2) Abs( ((float8) *((const t *) (arg1))) - ((float8) *((const t *) (arg2))) ) + + +extern Interval *abs_interval(Interval *a); + +extern bool gbt_num_consistent(const GBT_NUMKEY_R *key, const void *query, + const StrategyNumber *strategy, bool is_leaf, + const gbtree_ninfo *tinfo, FmgrInfo *flinfo); + +extern float8 gbt_num_distance(const GBT_NUMKEY_R *key, const void *query, + bool is_leaf, const gbtree_ninfo *tinfo, FmgrInfo *flinfo); + +extern GIST_SPLITVEC *gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, + const gbtree_ninfo *tinfo, FmgrInfo *flinfo); + +extern GISTENTRY *gbt_num_compress(GISTENTRY *entry, const gbtree_ninfo *tinfo); + +extern GISTENTRY *gbt_num_fetch(GISTENTRY *entry, const gbtree_ninfo *tinfo); + +extern void *gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, + const gbtree_ninfo *tinfo, FmgrInfo *flinfo); + +extern bool gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, + const gbtree_ninfo *tinfo, FmgrInfo *flinfo); + +extern void gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, + const gbtree_ninfo *tinfo, FmgrInfo *flinfo); + +#endif diff --git a/contrib/btree_gist/btree_utils_var.c b/contrib/btree_gist/btree_utils_var.c new file mode 100644 index 0000000..2886c08 --- /dev/null +++ b/contrib/btree_gist/btree_utils_var.c @@ -0,0 +1,612 @@ +/* + * contrib/btree_gist/btree_utils_var.c + */ +#include "postgres.h" + +#include <math.h> +#include <limits.h> +#include <float.h> + +#include "btree_gist.h" +#include "btree_utils_var.h" +#include "utils/builtins.h" +#include "utils/pg_locale.h" +#include "utils/rel.h" + +/* used for key sorting */ +typedef struct +{ + int i; + GBT_VARKEY *t; +} Vsrt; + +typedef struct +{ + const gbtree_vinfo *tinfo; + Oid collation; + FmgrInfo *flinfo; +} gbt_vsrt_arg; + + +PG_FUNCTION_INFO_V1(gbt_var_decompress); +PG_FUNCTION_INFO_V1(gbt_var_fetch); + + +Datum +gbt_var_decompress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GBT_VARKEY *key = (GBT_VARKEY *) PG_DETOAST_DATUM(entry->key); + + if (key != (GBT_VARKEY *) DatumGetPointer(entry->key)) + { + GISTENTRY *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY)); + + gistentryinit(*retval, PointerGetDatum(key), + entry->rel, entry->page, + entry->offset, false); + + PG_RETURN_POINTER(retval); + } + + PG_RETURN_POINTER(entry); +} + +/* Returns a better readable representation of variable key ( sets pointer ) */ +GBT_VARKEY_R +gbt_var_key_readable(const GBT_VARKEY *k) +{ + GBT_VARKEY_R r; + + r.lower = (bytea *) &(((char *) k)[VARHDRSZ]); + if (VARSIZE(k) > (VARHDRSZ + (VARSIZE(r.lower)))) + r.upper = (bytea *) &(((char *) k)[VARHDRSZ + INTALIGN(VARSIZE(r.lower))]); + else + r.upper = r.lower; + return r; +} + + +/* + * Create a leaf-entry to store in the index, from a single Datum. + */ +static GBT_VARKEY * +gbt_var_key_from_datum(const struct varlena *u) +{ + int32 lowersize = VARSIZE(u); + GBT_VARKEY *r; + + r = (GBT_VARKEY *) palloc(lowersize + VARHDRSZ); + memcpy(VARDATA(r), u, lowersize); + SET_VARSIZE(r, lowersize + VARHDRSZ); + + return r; +} + +/* + * Create an entry to store in the index, from lower and upper bound. + */ +GBT_VARKEY * +gbt_var_key_copy(const GBT_VARKEY_R *u) +{ + int32 lowersize = VARSIZE(u->lower); + int32 uppersize = VARSIZE(u->upper); + GBT_VARKEY *r; + + r = (GBT_VARKEY *) palloc0(INTALIGN(lowersize) + uppersize + VARHDRSZ); + memcpy(VARDATA(r), u->lower, lowersize); + memcpy(VARDATA(r) + INTALIGN(lowersize), u->upper, uppersize); + SET_VARSIZE(r, INTALIGN(lowersize) + uppersize + VARHDRSZ); + + return r; +} + + +static GBT_VARKEY * +gbt_var_leaf2node(GBT_VARKEY *leaf, const gbtree_vinfo *tinfo, FmgrInfo *flinfo) +{ + GBT_VARKEY *out = leaf; + + if (tinfo->f_l2n) + out = tinfo->f_l2n(leaf, flinfo); + + return out; +} + + +/* + * returns the common prefix length of a node key +*/ +static int32 +gbt_var_node_cp_len(const GBT_VARKEY *node, const gbtree_vinfo *tinfo) +{ + GBT_VARKEY_R r = gbt_var_key_readable(node); + int32 i = 0; + int32 l = 0; + int32 t1len = VARSIZE(r.lower) - VARHDRSZ; + int32 t2len = VARSIZE(r.upper) - VARHDRSZ; + int32 ml = Min(t1len, t2len); + char *p1 = VARDATA(r.lower); + char *p2 = VARDATA(r.upper); + + if (ml == 0) + return 0; + + while (i < ml) + { + if (tinfo->eml > 1 && l == 0) + { + if ((l = pg_mblen(p1)) != pg_mblen(p2)) + { + return i; + } + } + if (*p1 != *p2) + { + if (tinfo->eml > 1) + { + return (i - l + 1); + } + else + { + return i; + } + } + + p1++; + p2++; + l--; + i++; + } + return ml; /* lower == upper */ +} + + +/* + * returns true, if query matches prefix ( common prefix ) + */ +static bool +gbt_bytea_pf_match(const bytea *pf, const bytea *query, const gbtree_vinfo *tinfo) +{ + bool out = false; + int32 qlen = VARSIZE(query) - VARHDRSZ; + int32 nlen = VARSIZE(pf) - VARHDRSZ; + + if (nlen <= qlen) + { + char *q = VARDATA(query); + char *n = VARDATA(pf); + + out = (memcmp(q, n, nlen) == 0); + } + + return out; +} + + +/* + * returns true, if query matches node using common prefix + */ +static bool +gbt_var_node_pf_match(const GBT_VARKEY_R *node, const bytea *query, const gbtree_vinfo *tinfo) +{ + return (tinfo->trnc && + (gbt_bytea_pf_match(node->lower, query, tinfo) || + gbt_bytea_pf_match(node->upper, query, tinfo))); +} + + +/* +* truncates / compresses the node key +* cpf_length .. common prefix length +*/ +static GBT_VARKEY * +gbt_var_node_truncate(const GBT_VARKEY *node, int32 cpf_length, const gbtree_vinfo *tinfo) +{ + GBT_VARKEY *out = NULL; + GBT_VARKEY_R r = gbt_var_key_readable(node); + int32 len1 = VARSIZE(r.lower) - VARHDRSZ; + int32 len2 = VARSIZE(r.upper) - VARHDRSZ; + int32 si; + char *out2; + + len1 = Min(len1, (cpf_length + 1)); + len2 = Min(len2, (cpf_length + 1)); + + si = 2 * VARHDRSZ + INTALIGN(len1 + VARHDRSZ) + len2; + out = (GBT_VARKEY *) palloc0(si); + SET_VARSIZE(out, si); + + memcpy(VARDATA(out), r.lower, len1 + VARHDRSZ); + SET_VARSIZE(VARDATA(out), len1 + VARHDRSZ); + + out2 = VARDATA(out) + INTALIGN(len1 + VARHDRSZ); + memcpy(out2, r.upper, len2 + VARHDRSZ); + SET_VARSIZE(out2, len2 + VARHDRSZ); + + return out; +} + + + +void +gbt_var_bin_union(Datum *u, GBT_VARKEY *e, Oid collation, + const gbtree_vinfo *tinfo, FmgrInfo *flinfo) +{ + GBT_VARKEY_R eo = gbt_var_key_readable(e); + GBT_VARKEY_R nr; + + if (eo.lower == eo.upper) /* leaf */ + { + GBT_VARKEY *tmp; + + tmp = gbt_var_leaf2node(e, tinfo, flinfo); + if (tmp != e) + eo = gbt_var_key_readable(tmp); + } + + if (DatumGetPointer(*u)) + { + GBT_VARKEY_R ro = gbt_var_key_readable((GBT_VARKEY *) DatumGetPointer(*u)); + bool update = false; + + nr.lower = ro.lower; + nr.upper = ro.upper; + + if (tinfo->f_cmp(ro.lower, eo.lower, collation, flinfo) > 0) + { + nr.lower = eo.lower; + update = true; + } + + if (tinfo->f_cmp(ro.upper, eo.upper, collation, flinfo) < 0) + { + nr.upper = eo.upper; + update = true; + } + + if (update) + *u = PointerGetDatum(gbt_var_key_copy(&nr)); + } + else + { + nr.lower = eo.lower; + nr.upper = eo.upper; + *u = PointerGetDatum(gbt_var_key_copy(&nr)); + } +} + + +GISTENTRY * +gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo *tinfo) +{ + GISTENTRY *retval; + + if (entry->leafkey) + { + struct varlena *leaf = PG_DETOAST_DATUM(entry->key); + GBT_VARKEY *r; + + r = gbt_var_key_from_datum(leaf); + + retval = palloc(sizeof(GISTENTRY)); + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, true); + } + else + retval = entry; + + return retval; +} + + +Datum +gbt_var_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GBT_VARKEY *key = (GBT_VARKEY *) PG_DETOAST_DATUM(entry->key); + GBT_VARKEY_R r = gbt_var_key_readable(key); + GISTENTRY *retval; + + retval = palloc(sizeof(GISTENTRY)); + gistentryinit(*retval, PointerGetDatum(r.lower), + entry->rel, entry->page, + entry->offset, true); + + PG_RETURN_POINTER(retval); +} + + +GBT_VARKEY * +gbt_var_union(const GistEntryVector *entryvec, int32 *size, Oid collation, + const gbtree_vinfo *tinfo, FmgrInfo *flinfo) +{ + int i = 0, + numranges = entryvec->n; + GBT_VARKEY *cur; + Datum out; + GBT_VARKEY_R rk; + + *size = sizeof(GBT_VARKEY); + + cur = (GBT_VARKEY *) DatumGetPointer(entryvec->vector[0].key); + rk = gbt_var_key_readable(cur); + out = PointerGetDatum(gbt_var_key_copy(&rk)); + + for (i = 1; i < numranges; i++) + { + cur = (GBT_VARKEY *) DatumGetPointer(entryvec->vector[i].key); + gbt_var_bin_union(&out, cur, collation, tinfo, flinfo); + } + + + /* Truncate (=compress) key */ + if (tinfo->trnc) + { + int32 plen; + GBT_VARKEY *trc = NULL; + + plen = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(out), tinfo); + trc = gbt_var_node_truncate((GBT_VARKEY *) DatumGetPointer(out), plen + 1, tinfo); + + out = PointerGetDatum(trc); + } + + return ((GBT_VARKEY *) DatumGetPointer(out)); +} + + +bool +gbt_var_same(Datum d1, Datum d2, Oid collation, + const gbtree_vinfo *tinfo, FmgrInfo *flinfo) +{ + GBT_VARKEY *t1 = (GBT_VARKEY *) DatumGetPointer(d1); + GBT_VARKEY *t2 = (GBT_VARKEY *) DatumGetPointer(d2); + GBT_VARKEY_R r1, + r2; + + r1 = gbt_var_key_readable(t1); + r2 = gbt_var_key_readable(t2); + + return (tinfo->f_cmp(r1.lower, r2.lower, collation, flinfo) == 0 && + tinfo->f_cmp(r1.upper, r2.upper, collation, flinfo) == 0); +} + + +float * +gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, + Oid collation, const gbtree_vinfo *tinfo, FmgrInfo *flinfo) +{ + GBT_VARKEY *orge = (GBT_VARKEY *) DatumGetPointer(o->key); + GBT_VARKEY *newe = (GBT_VARKEY *) DatumGetPointer(n->key); + GBT_VARKEY_R ok, + nk; + + *res = 0.0; + + nk = gbt_var_key_readable(newe); + if (nk.lower == nk.upper) /* leaf */ + { + GBT_VARKEY *tmp; + + tmp = gbt_var_leaf2node(newe, tinfo, flinfo); + if (tmp != newe) + nk = gbt_var_key_readable(tmp); + } + ok = gbt_var_key_readable(orge); + + if ((VARSIZE(ok.lower) - VARHDRSZ) == 0 && (VARSIZE(ok.upper) - VARHDRSZ) == 0) + *res = 0.0; + else if (!((tinfo->f_cmp(nk.lower, ok.lower, collation, flinfo) >= 0 || + gbt_bytea_pf_match(ok.lower, nk.lower, tinfo)) && + (tinfo->f_cmp(nk.upper, ok.upper, collation, flinfo) <= 0 || + gbt_bytea_pf_match(ok.upper, nk.upper, tinfo)))) + { + Datum d = PointerGetDatum(0); + double dres; + int32 ol, + ul; + + gbt_var_bin_union(&d, orge, collation, tinfo, flinfo); + ol = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(d), tinfo); + gbt_var_bin_union(&d, newe, collation, tinfo, flinfo); + ul = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(d), tinfo); + + if (ul < ol) + { + dres = (ol - ul); /* reduction of common prefix len */ + } + else + { + GBT_VARKEY_R uk = gbt_var_key_readable((GBT_VARKEY *) DatumGetPointer(d)); + unsigned char tmp[4]; + + tmp[0] = (unsigned char) (((VARSIZE(ok.lower) - VARHDRSZ) <= ul) ? 0 : (VARDATA(ok.lower)[ul])); + tmp[1] = (unsigned char) (((VARSIZE(uk.lower) - VARHDRSZ) <= ul) ? 0 : (VARDATA(uk.lower)[ul])); + tmp[2] = (unsigned char) (((VARSIZE(ok.upper) - VARHDRSZ) <= ul) ? 0 : (VARDATA(ok.upper)[ul])); + tmp[3] = (unsigned char) (((VARSIZE(uk.upper) - VARHDRSZ) <= ul) ? 0 : (VARDATA(uk.upper)[ul])); + dres = Abs(tmp[0] - tmp[1]) + Abs(tmp[3] - tmp[2]); + dres /= 256.0; + } + + *res += FLT_MIN; + *res += (float) (dres / ((double) (ol + 1))); + *res *= (FLT_MAX / (o->rel->rd_att->natts + 1)); + } + + return res; +} + + +static int +gbt_vsrt_cmp(const void *a, const void *b, void *arg) +{ + GBT_VARKEY_R ar = gbt_var_key_readable(((const Vsrt *) a)->t); + GBT_VARKEY_R br = gbt_var_key_readable(((const Vsrt *) b)->t); + const gbt_vsrt_arg *varg = (const gbt_vsrt_arg *) arg; + int res; + + res = varg->tinfo->f_cmp(ar.lower, br.lower, varg->collation, varg->flinfo); + if (res == 0) + return varg->tinfo->f_cmp(ar.upper, br.upper, varg->collation, varg->flinfo); + + return res; +} + +GIST_SPLITVEC * +gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, + Oid collation, const gbtree_vinfo *tinfo, FmgrInfo *flinfo) +{ + OffsetNumber i, + maxoff = entryvec->n - 1; + Vsrt *arr; + int svcntr = 0, + nbytes; + char *cur; + GBT_VARKEY **sv = NULL; + gbt_vsrt_arg varg; + + arr = (Vsrt *) palloc((maxoff + 1) * sizeof(Vsrt)); + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + v->spl_ldatum = PointerGetDatum(0); + v->spl_rdatum = PointerGetDatum(0); + v->spl_nleft = 0; + v->spl_nright = 0; + + sv = palloc(sizeof(bytea *) * (maxoff + 1)); + + /* Sort entries */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + GBT_VARKEY_R ro; + + cur = (char *) DatumGetPointer(entryvec->vector[i].key); + ro = gbt_var_key_readable((GBT_VARKEY *) cur); + if (ro.lower == ro.upper) /* leaf */ + { + sv[svcntr] = gbt_var_leaf2node((GBT_VARKEY *) cur, tinfo, flinfo); + arr[i].t = sv[svcntr]; + if (sv[svcntr] != (GBT_VARKEY *) cur) + svcntr++; + } + else + arr[i].t = (GBT_VARKEY *) cur; + arr[i].i = i; + } + + /* sort */ + varg.tinfo = tinfo; + varg.collation = collation; + varg.flinfo = flinfo; + qsort_arg((void *) &arr[FirstOffsetNumber], + maxoff - FirstOffsetNumber + 1, + sizeof(Vsrt), + gbt_vsrt_cmp, + (void *) &varg); + + /* We do simply create two parts */ + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + if (i <= (maxoff - FirstOffsetNumber + 1) / 2) + { + gbt_var_bin_union(&v->spl_ldatum, arr[i].t, collation, tinfo, flinfo); + v->spl_left[v->spl_nleft] = arr[i].i; + v->spl_nleft++; + } + else + { + gbt_var_bin_union(&v->spl_rdatum, arr[i].t, collation, tinfo, flinfo); + v->spl_right[v->spl_nright] = arr[i].i; + v->spl_nright++; + } + } + + /* Truncate (=compress) key */ + if (tinfo->trnc) + { + int32 ll = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(v->spl_ldatum), tinfo); + int32 lr = gbt_var_node_cp_len((GBT_VARKEY *) DatumGetPointer(v->spl_rdatum), tinfo); + GBT_VARKEY *dl; + GBT_VARKEY *dr; + + ll = Max(ll, lr); + ll++; + + dl = gbt_var_node_truncate((GBT_VARKEY *) DatumGetPointer(v->spl_ldatum), ll, tinfo); + dr = gbt_var_node_truncate((GBT_VARKEY *) DatumGetPointer(v->spl_rdatum), ll, tinfo); + v->spl_ldatum = PointerGetDatum(dl); + v->spl_rdatum = PointerGetDatum(dr); + } + + return v; +} + + +/* + * The GiST consistent method + */ +bool +gbt_var_consistent(GBT_VARKEY_R *key, + const void *query, + StrategyNumber strategy, + Oid collation, + bool is_leaf, + const gbtree_vinfo *tinfo, + FmgrInfo *flinfo) +{ + bool retval = false; + + switch (strategy) + { + case BTLessEqualStrategyNumber: + if (is_leaf) + retval = tinfo->f_ge(query, key->lower, collation, flinfo); + else + retval = tinfo->f_cmp(query, key->lower, collation, flinfo) >= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + case BTLessStrategyNumber: + if (is_leaf) + retval = tinfo->f_gt(query, key->lower, collation, flinfo); + else + retval = tinfo->f_cmp(query, key->lower, collation, flinfo) >= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + case BTEqualStrategyNumber: + if (is_leaf) + retval = tinfo->f_eq(query, key->lower, collation, flinfo); + else + retval = + (tinfo->f_cmp(key->lower, query, collation, flinfo) <= 0 && + tinfo->f_cmp(query, key->upper, collation, flinfo) <= 0) || + gbt_var_node_pf_match(key, query, tinfo); + break; + case BTGreaterStrategyNumber: + if (is_leaf) + retval = tinfo->f_lt(query, key->upper, collation, flinfo); + else + retval = tinfo->f_cmp(query, key->upper, collation, flinfo) <= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + case BTGreaterEqualStrategyNumber: + if (is_leaf) + retval = tinfo->f_le(query, key->upper, collation, flinfo); + else + retval = tinfo->f_cmp(query, key->upper, collation, flinfo) <= 0 + || gbt_var_node_pf_match(key, query, tinfo); + break; + case BtreeGistNotEqualStrategyNumber: + retval = !(tinfo->f_eq(query, key->lower, collation, flinfo) && + tinfo->f_eq(query, key->upper, collation, flinfo)); + break; + default: + retval = false; + } + + return retval; +} diff --git a/contrib/btree_gist/btree_utils_var.h b/contrib/btree_gist/btree_utils_var.h new file mode 100644 index 0000000..2f8def6 --- /dev/null +++ b/contrib/btree_gist/btree_utils_var.h @@ -0,0 +1,72 @@ +/* + * contrib/btree_gist/btree_utils_var.h + */ +#ifndef __BTREE_UTILS_VAR_H__ +#define __BTREE_UTILS_VAR_H__ + +#include "access/gist.h" +#include "btree_gist.h" +#include "mb/pg_wchar.h" + +/* Variable length key */ +typedef bytea GBT_VARKEY; + +/* Better readable key */ +typedef struct +{ + bytea *lower, + *upper; +} GBT_VARKEY_R; + +/* + * type description + */ +typedef struct +{ + + /* Attribs */ + + enum gbtree_type t; /* data type */ + int32 eml; /* cached pg_database_encoding_max_length (0: + * undefined) */ + bool trnc; /* truncate (=compress) key */ + + /* Methods */ + + bool (*f_gt) (const void *, const void *, Oid, FmgrInfo *); /* greater than */ + bool (*f_ge) (const void *, const void *, Oid, FmgrInfo *); /* greater equal */ + bool (*f_eq) (const void *, const void *, Oid, FmgrInfo *); /* equal */ + bool (*f_le) (const void *, const void *, Oid, FmgrInfo *); /* less equal */ + bool (*f_lt) (const void *, const void *, Oid, FmgrInfo *); /* less than */ + int32 (*f_cmp) (const void *, const void *, Oid, FmgrInfo *); /* compare */ + GBT_VARKEY *(*f_l2n) (GBT_VARKEY *, FmgrInfo *flinfo); /* convert leaf to node */ +} gbtree_vinfo; + + + +extern GBT_VARKEY_R gbt_var_key_readable(const GBT_VARKEY *k); + +extern GBT_VARKEY *gbt_var_key_copy(const GBT_VARKEY_R *u); + +extern GISTENTRY *gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo *tinfo); + +extern GBT_VARKEY *gbt_var_union(const GistEntryVector *entryvec, int32 *size, + Oid collation, const gbtree_vinfo *tinfo, FmgrInfo *flinfo); + +extern bool gbt_var_same(Datum d1, Datum d2, Oid collation, + const gbtree_vinfo *tinfo, FmgrInfo *flinfo); + +extern float *gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, + Oid collation, const gbtree_vinfo *tinfo, FmgrInfo *flinfo); + +extern bool gbt_var_consistent(GBT_VARKEY_R *key, const void *query, + StrategyNumber strategy, Oid collation, bool is_leaf, + const gbtree_vinfo *tinfo, FmgrInfo *flinfo); + +extern GIST_SPLITVEC *gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, + Oid collation, const gbtree_vinfo *tinfo, FmgrInfo *flinfo); + +extern void gbt_var_bin_union(Datum *u, GBT_VARKEY *e, Oid collation, + const gbtree_vinfo *tinfo, FmgrInfo *flinfo); + +#endif diff --git a/contrib/btree_gist/btree_uuid.c b/contrib/btree_gist/btree_uuid.c new file mode 100644 index 0000000..b818759 --- /dev/null +++ b/contrib/btree_gist/btree_uuid.c @@ -0,0 +1,235 @@ +/* + * contrib/btree_gist/btree_uuid.c + */ +#include "postgres.h" + +#include "btree_gist.h" +#include "btree_utils_num.h" +#include "port/pg_bswap.h" +#include "utils/uuid.h" + +typedef struct +{ + pg_uuid_t lower, + upper; +} uuidKEY; + + +/* + * UUID ops + */ +PG_FUNCTION_INFO_V1(gbt_uuid_compress); +PG_FUNCTION_INFO_V1(gbt_uuid_fetch); +PG_FUNCTION_INFO_V1(gbt_uuid_union); +PG_FUNCTION_INFO_V1(gbt_uuid_picksplit); +PG_FUNCTION_INFO_V1(gbt_uuid_consistent); +PG_FUNCTION_INFO_V1(gbt_uuid_penalty); +PG_FUNCTION_INFO_V1(gbt_uuid_same); + + +static int +uuid_internal_cmp(const pg_uuid_t *arg1, const pg_uuid_t *arg2) +{ + return memcmp(arg1->data, arg2->data, UUID_LEN); +} + +static bool +gbt_uuidgt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) > 0; +} + +static bool +gbt_uuidge(const void *a, const void *b, FmgrInfo *flinfo) +{ + return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) >= 0; +} + +static bool +gbt_uuideq(const void *a, const void *b, FmgrInfo *flinfo) +{ + return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) == 0; +} + +static bool +gbt_uuidle(const void *a, const void *b, FmgrInfo *flinfo) +{ + return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) <= 0; +} + +static bool +gbt_uuidlt(const void *a, const void *b, FmgrInfo *flinfo) +{ + return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) < 0; +} + +static int +gbt_uuidkey_cmp(const void *a, const void *b, FmgrInfo *flinfo) +{ + uuidKEY *ia = (uuidKEY *) (((const Nsrt *) a)->t); + uuidKEY *ib = (uuidKEY *) (((const Nsrt *) b)->t); + int res; + + res = uuid_internal_cmp(&ia->lower, &ib->lower); + if (res == 0) + res = uuid_internal_cmp(&ia->upper, &ib->upper); + return res; +} + + +static const gbtree_ninfo tinfo = +{ + gbt_t_uuid, + UUID_LEN, + 32, /* sizeof(gbtreekey32) */ + gbt_uuidgt, + gbt_uuidge, + gbt_uuideq, + gbt_uuidle, + gbt_uuidlt, + gbt_uuidkey_cmp, + NULL +}; + + +/************************************************** + * uuid ops + **************************************************/ + + +Datum +gbt_uuid_compress(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; + + if (entry->leafkey) + { + char *r = (char *) palloc(2 * UUID_LEN); + pg_uuid_t *key = DatumGetUUIDP(entry->key); + + retval = palloc(sizeof(GISTENTRY)); + + memcpy((void *) r, (void *) key, UUID_LEN); + memcpy((void *) (r + UUID_LEN), (void *) key, UUID_LEN); + gistentryinit(*retval, PointerGetDatum(r), + entry->rel, entry->page, + entry->offset, false); + } + else + retval = entry; + + PG_RETURN_POINTER(retval); +} + +Datum +gbt_uuid_fetch(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + + PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo)); +} + +Datum +gbt_uuid_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + pg_uuid_t *query = PG_GETARG_UUID_P(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + uuidKEY *kkk = (uuidKEY *) DatumGetPointer(entry->key); + GBT_NUMKEY_R key; + + /* All cases served by this function are exact */ + *recheck = false; + + key.lower = (GBT_NUMKEY *) &kkk->lower; + key.upper = (GBT_NUMKEY *) &kkk->upper; + + PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) query, &strategy, + GIST_LEAF(entry), &tinfo, + fcinfo->flinfo)); +} + +Datum +gbt_uuid_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + void *out = palloc(sizeof(uuidKEY)); + + *(int *) PG_GETARG_POINTER(1) = sizeof(uuidKEY); + PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo)); +} + +/* + * Convert a uuid to a "double" value for estimating sizes of ranges. + */ +static double +uuid_2_double(const pg_uuid_t *u) +{ + uint64 uu[2]; + const double two64 = 18446744073709551616.0; /* 2^64 */ + + /* Source data may not be suitably aligned, so copy */ + memcpy(uu, u->data, UUID_LEN); + + /* + * uuid values should be considered as big-endian numbers, since that + * corresponds to how memcmp will compare them. On a little-endian + * machine, byte-swap each half so we can use native uint64 arithmetic. + */ +#ifndef WORDS_BIGENDIAN + uu[0] = pg_bswap64(uu[0]); + uu[1] = pg_bswap64(uu[1]); +#endif + + /* + * 2^128 is about 3.4e38, which in theory could exceed the range of + * "double" (POSIX only requires 1e37). To avoid any risk of overflow, + * put the decimal point between the two halves rather than treating the + * uuid value as a 128-bit integer. + */ + return (double) uu[0] + (double) uu[1] / two64; +} + +Datum +gbt_uuid_penalty(PG_FUNCTION_ARGS) +{ + uuidKEY *origentry = (uuidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + uuidKEY *newentry = (uuidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + double olower, + oupper, + nlower, + nupper; + + olower = uuid_2_double(&origentry->lower); + oupper = uuid_2_double(&origentry->upper); + nlower = uuid_2_double(&newentry->lower); + nupper = uuid_2_double(&newentry->upper); + + penalty_num(result, olower, oupper, nlower, nupper); + + PG_RETURN_POINTER(result); +} + +Datum +gbt_uuid_picksplit(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + &tinfo, fcinfo->flinfo)); +} + +Datum +gbt_uuid_same(PG_FUNCTION_ARGS) +{ + uuidKEY *b1 = (uuidKEY *) PG_GETARG_POINTER(0); + uuidKEY *b2 = (uuidKEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo); + PG_RETURN_POINTER(result); +} diff --git a/contrib/btree_gist/data/bit.data b/contrib/btree_gist/data/bit.data new file mode 100644 index 0000000..0d07719 --- /dev/null +++ b/contrib/btree_gist/data/bit.data @@ -0,0 +1,612 @@ +010000100100001100101100011110110 +010110001111011000001101000000101 +101100011110110000011010000001010 +001101100101000001110001000001101 +000110100111111111101001011111010 +001100000100111101000011111100000 +001100010100010001010010000011010 +000101001000001101000111100100010 +110110101100010001000101001111000 +110110110110100010000110100000011 +110101011101101111110111110010101 +010001111000000110010101010011100 +111010010111110101101100110011010 +010000100100001100101100011110110 +010101001101100101000001110001000 +110111101011110001111110011001011 +110001011110101000011101101011100 +011001011010100000000100000111100 +101000011101100110000111010100111 +011000111000011011110101010001110 +000111001110101000110000011000000 +110101000010001101010111011000001 +010100100000010110010011011111111 +110000110011011010111101010001100 +101010100110000010011110100001111 +\N +100000111100001111011001001011101 +111100100011001110101000010010111 +011010001111111111011100001011110 +110010001100111010100001001011101 +110110111111010010100111110010001 +101110011110000110000000000110110 +100100110000001101010111100111010 +001001010111100011101101100001100 +010000001100010100010001010010000 +111010000100100110101011011101010 +110100001000001100111000111101100 +111011001111111001111000111010110 +111111100000010110100111101011011 +011011111111101110110011111110011 +110100001000001100111000111101100 +001011101101010100101010010010001 +101010011100100011011000001101011 +000000110100000111011101010011101 +110100101111101011011001100110100 +011111010110110011001101000000110 +101010001100000110000000111000101 +101111111011001001001000000000011 +011000101100111000010011000100001 +000110101011110011101000000110001 +000111110101111010110000111011011 +100010001100101110011000110010110 +010000011010001111001000101000001 +111010001111010110101111010110111 +100110011011011100001001001010101 +110010010110011101110111101011110 +110010101101000011111111101110100 +011101011111111001100010010000011 +010100010011011011001100011100001 +110110111111010010100111110010001 +000011101110111100110111100111011 +101011110101101111111110111011001 +001100010001110100010010100101101 +111101011011001100110100000011000 +000000100000101101010100000110000 +101010110100010000001111010010010 +010111010011000101010110111000011 +100101101101101111001100111010000 +000001100110111000101101100001110 +\N +110110111101010000011111100010000 +100010001010010000011010001111001 +110010100010110100100110000111010 +101101101101111001100111010000100 +010111101011000011101101110001011 +100000000000010101110011011100010 +100001101000010101111101001010100 +101000110001011001110000100110001 +110011011111011100010000010100011 +010011011100110000100001001100111 +001100010101110001110101111001001 +001110000010000001100011000110001 +000110001100011010111111101011100 +100010001111110100101100110010110 +000001001100110110111000010010010 +111101100100101110101100111001100 +010101011101100001111111110011011 +001011111111001100101101110101001 +110111111111111110111000010011001 +010101111001101011011111011111000 +011110111100101001000111111001100 +010111001001111010011000101000011 +010001110111111100000011100100000 +100001111111001110011001110010101 +011000010110001010011011011101111 +000000001010111001101110001011010 +100011100000001111011010011010110 +000011100100110111000001010001111 +100101010111110110000011001010101 +110000101100110010000010011001011 +110010000001011101011110110011011 +100010111100001111111001110011001 +111111101111101000000100000011111 +110100101011110110101110001101011 +011110111111010101011000001000111 +011111111110011001110011101100000 +101101000110001011001110000100110 +010101001001011011110110100010100 +011111111100000010110100111101011 +011000111101111110011000000010011 +011000010001000000000110101011001 +011011000100010111011000110000100 +100101100011111101110100011101000 +011100000011111110111111010011010 +010010111001111100010110011011111 +001100101111111101111111111111101 +111111111010000010101110100011011 +111010000110101001111001000101100 +100101100000000000010101110011011 +010001011000010010101100010001100 +010010011110010010111001100101111 +111010011101110110101110011110000 +000011100111010011100001111110110 +101110010010010010101100001001000 +100100011001010000011100100011101 +010111110001111111100101000100100 +110100000100101001110000111100011 +011111000111001100101111111101011 +110010000111111011111001001110111 +010111001111000011000000000011011 +110000110101111010101010110111000 +000111101001100011111110011000011 +000001001010011100001111000110000 +010010001101001110010001111111000 +010111101011000011101101110001011 +\N +001001111001011100001010100101110 +110001110011100000000010000001001 +101111111111110101101111000110010 +011101111110011101110000001001111 +011010110001101010110010110101001 +101100110001100101011011001001111 +000000010010010111110001010001110 +110101110100110000100010011000100 +100101000100111110111001101101111 +101110000111100000110110101111001 +011111111001010001001001001001111 +111110011001011110111111010101011 +011100100000111101110001101000101 +011100100011001100011001010100000 +001010110101101100000100001101011 +101011000101101010000110110100000 +010000000011011000111010010001011 +001110100100010110110010010000001 +110111001101011111110000101100110 +101110001010111110110111111101011 +001111001010011010101101110011101 +000001001100000110100001111011001 +111011101010011101001100011011010 +101111000101101101101100100100011 +011011110011101101000111111111101 +000011101101101000001000111001111 +001101001110010001111111000110101 +101001010100000100011101110010101 +111001010010001111110011000100010 +001011110000110111001000010100010 +001110010010111110110111001111100 +000100111100100111010100010110001 +101000100111110111001101101111001 +111001011110111111101000111011011 +001011111111010111011001110101010 +000110101001110010100110000100000 +111000000101001000110111010011101 +011011000100000001010111111111101 +011011100001110101100100111100101 +111101101010011001110011001110000 +011000101001000010010101110101001 +010101001110100011110101101011110 +011011101001110100001000100011011 +110101111110011101101110100101111 +011011010101001110010000011000111 +100010110000000001111111001110011 +100100101110011001011110111100011 +001001100010001110001000000111000 +010000001101010001010011001100001 +011110011010110111110111110001011 +111111110100110111010010111011000 +101111111011001001001000000000011 +010110111101101000101001010010101 +001101010101100100100011001010001 +000011101100110000111010100111001 +111010001111010110101111010110111 +000110101111000101010101010100010 +111001100111011100000100011000110 +011110111111011100111010000100010 +000111010100111001001010100010001 +111010011111010100100101011110101 +110100100101011010100001010010010 +001111110001110100100101001001110 +100101011111001100101010011110101 +011110010111101001010011000110000 +\N +011101010001011000110110001000101 +010100100100111000000011000110000 +100110111100110110010011111010110 +\N +001000000010011011010000010001100 +010010101010101001000001111001010 +111100100111010100010110001101100 +111100000110010010101010101001000 +100001001000110101000110110101101 +110100000011011101011010101000101 +110111000010000001110000110011001 +011110001010101100110100000000111 +000100100111011010000000010100100 +010001000000000110101011001111100 +100110010101001110000100110101111 +001111100010011010000011000100101 +010010011000100111111101000011001 +000010001110101101111111010000010 +001100001101111000010100100110111 +100011011010000111000011111000011 +000110110101000010101001111110100 +110100101010010100101100101101111 +111111001110111000000100111110001 +101100101011101101001111011100100 +011100110011001001101000100101000 +101000110100100101011101110110100 +010100010111000111010100101100111 +011011101001100000011000011011100 +110011001100101111101010001011111 +001101110000011111001010010101010 +000001111010000111101011111110000 +000111000001010111110111000001010 +000000001111111001110011000100100 +100111110011111100011001100110110 +111001011000100001001001101101001 +000111010011100101101001110001010 +010011101101000100111101110010011 +000010101110100011011011011010101 +001001101111010001101101001111010 +011011110111110010110100000110110 +110011000010000100110011101111010 +010101110101101000000110010010011 +011000001101000011110110011000110 +101001111010100010000000110101011 +100110101111010100000000100101101 +010110000100110010110101111001111 +011000010101111101001110111000011 +011110010110100100100010110100101 +010101001001011011110110100010100 +010001110011100000010000111110001 +100101011010100001010010010011100 +100000100011000000010010010111110 +000101100110000011000110101010010 +010110100011010001001000011011000 +000010100100100111000000011000110 +101000011110001101000110110100000 +101011110100110000010011101110011 +011001010111111000100010101001001 +001100010111101100011011110101001 +110010001111010010111000101000100 +110111000010111101110101011100110 +100010011110010011100011011010000 +010010011010100000011000110010010 +001111011111100110000000100111011 +101100101001001010000000010100000 +111110100101011010100010110001100 +010110010111101001100010101110001 +011101110000000000001001010101100 +100011111001010101110010000001111 +100001011000111001011011011010100 +010001110010010000101010001100010 +100100000110000111001111110000010 +011101110011111100001001010010010 +011101111010111101101000001101100 +110101100100110001110111111010010 +011101011001010101000010010101101 +000111100101111010010100110001100 +111110101110101100111011110001001 +100001111011100011110100110001111 +001100001010101111101001111101100 +001100000010010010110110110001111 +111110110110011000111011001110010 +101011000111011111011000110010111 +001111011111100110000000100111011 +100001100000111111110110101010100 +101011111011000100011110110001101 +111010111111110011000100100000111 +100100101100010111010000000011110 +111100000110010010101010101001000 +110101111111111100100111010000000 +100101001010010110111000100000111 +010000011111100010000110111111110 +011001010011000110111110100000001 +101101001010011101101111111010111 +111000110011001101101010001111010 +110001011100101100011100000101011 +010010110011001011000001010110100 +101111101110001001110111100100010 +000011001101110110101101010111011 +101010000010100100111111000111001 +101110101111010101000101110001110 +101110000001001101010101100000111 +000101001010010101100100001111110 +111011100110001100010000001011001 +101011011011111010000101001100000 +101011101110000001010010011010100 +111101010011000111100001101011000 +001001000010101110111110001101011 +101110110011000011111000010101011 +100110000011011111010010010001100 +000010101000110110111110101000101 +110010001110000110000101111100001 +011000110010110010110101000000001 +001111000111000001100100011001111 +011001101100000011000101100111101 +110000101101101110001110010101011 +100101011011111110011011001000010 +101111111001111111101010101100010 +111111110110101010100101111010101 +010101101000011011001110100010101 +101000001101001111101111001110010 +011100000100100100000000100010111 +010011000110111110100000001110001 +111101011111011000001011000110110 +101010000011100110110111011011101 +100110110111010111110111100101010 +011111001101001001110110000011011 +101001101010010010000001011010100 +101101111111001011011111000010111 +001100111000000011100111010011100 +101001001111001001011100110010111 +101011110010000110110101100110011 +011001010101010001111001101100011 +010111111001111111011110000000001 +010010001111001011101001111001000 +\N +000111010010001100010010101001101 +010110100111000000101001010110011 +111010000100100000011111110010110 +111000000111110111100010110110110 +110111101000100000011101110011111 +011110110100111000101110010000010 +011111011010100100011000011011010 +010001011000001001110100010101110 +100101000100111110101000001100110 +001011100001010111001011101011101 +101110001110011001100101111101010 +110100101001100011111011100100011 +101001000110000110110101000010101 +111010000110101001111001000101100 +100011110000011001001010101010100 +101111010110100110100010001111011 +000010110000101101100011001011001 +001011001000010011001111011110000 +110011110111110000001011011101101 +000101000110110100000100110100100 +000100010111011111011100100110100 +\N +101011101110111111010000000100010 +000100100100001100010111010101010 +\N +000100011001010101010001111001101 +111101010100010000011100101011000 +110000000110001011101000000101110 +111101111100110011010110100001000 +000011011101011010101000101001010 +010110000000001001010101001001111 +100110111111100011110011111111010 +010110100110000111000011100001111 +001000111100110111111010000101110 +100100010000101110011101011101110 +011111111110001100110110001100001 +010000100001110001100010101100101 +000001110111001001001001110000110 +101101001110001010000101101001011 +110011101010000100101110110101010 +100100100011000000001111100011001 +001000111111001100010001011000001 +111001100101010011110101000100000 +111001001100100110010001000000111 +110001111110010111111100010110100 +000111110001111010011011100110000 +001001011110001111111011010000100 +101110110011000000100111000111000 +101111000100000111011011111110001 +000011111101111100100111011111110 +001110100110101101111011110101001 +011000101001011110000011110100001 +100000001001111110101110000101100 +100010000110010101001010010000110 +111101010111001101101011000000111 +101010100000100101010101111010000 +011101111101110010011010010010110 +100010001010001101110011000010010 +101101100101101111000110110000010 +100111010011000110110101010111000 +000101101011111110110000111111010 +001100101110000011000110000111000 +100010010110111011001111000100000 +011000000000011110100100110100101 +101001100011111011100100011011010 +001111010111100101111100000010001 +111000000001101011110001010101010 +101101011011000001000011010110111 +\N +000000000111110111111011110000110 +110010001010000100001001100100011 +001100011001110011101010011100000 +111111101010010001000000100100111 +010000000011101111000010000100011 +001011010101110011111100000001100 +101010000010100011010001111000110 +101010111100111010000001100010111 +011001110111110111110010001100010 +110010101100000010110110101111110 +111000001001001000000001000101111 +000001101000001100101001000101001 +010111101011011111111101110110011 +010001101101111101010001011011001 +100101100000111100000110101101000 +011110000001011100011110110110100 +000100101100101110101001000000001 +011011101110011011110001111011101 +000110101011001100010101111010110 +011111000000000010011001101101110 +100110001011110110001101111010100 +111100100100100111110001001001011 +100110110100111110100011000000000 +011000001001101110101110110110011 +111100110101011000001110110110011 +101001101100110111110111100100101 +000001111100010110110101100011000 +001100011100001000000101110110010 +011001011010101000110011010011111 +110010100010110001000001001111011 +100001001000011001011000111101100 +001010011110011101001000010011000 +000000101101001011001100100001101 +011100000010100110001010110100000 +011011001101111101010001110011001 +000001000111100110111111010000101 +110101110010010011011010111111000 +100111010111001110010000100001110 +101101001100011010001001010011000 +010111011011001110100110111011001 +001001001011100010011010100111010 +000000011001110101001110000100100 +011110101001010011110101101000001 +000101011101000000011101010100111 +001100111111011001000100101110100 +010101100011000101111011110000101 +111101010111001101101011000000111 +111000110100101011010010100111011 +111010011010111101000010101110000 +100111100110001110100100101001100 +111010010000100000101000000100001 +011000011110101111101100010001111 +100000110110010111010011101110010 +010100011111011000111100001100100 +010101010110001011011001110111101 +010101110100001010000000000010111 +111001011110010010010000001010000 +000100011110111010010101011000110 +111011000100000001100010100011010 +011111100010010111101010010000101 +001010111111111101110111101011000 +010111111010100100101010000101101 +111101010100100000100000101011100 +000001101100101110100111011100101 +111100100011110100101111010101101 +\N +111111000010000001001100010110000 +111110100000010101001110010011110 +110000011110100001111010111111100 +111001101110001011010110001100100 +000100000010110010100100110011100 +111010001001011011101100111100010 +011001101101011110101000110001101 +100100110000001101010111100111010 +111000001010000010011111111000000 +011111001101011101101110111011100 +000000011011110100000011000100011 +000100110101100010010001101001000 +101000110001101011000100010001001 +110111101110011000110101101010101 +001101110010000101000101101101000 +100001001000011001011000111101100 +111110111010010111000011010011111 +001110100001000100010111101110110 +000101000111010000010111010010100 +110101010100101100110100111001110 +011110101011101111100101010000000 +000101110100100011000011111110000 +001011101110001111101110101101100 +110100010010001111111100100011010 +101010001100010000011101011111111 +101000010000100010101000011111111 +000000010101011110111110100110111 +110111001001101111100011010000101 +100010000000001100000111000010100 +011110101010110101010000011001000 +110110110111100010000111000110000 +110001111110010100010100011111100 +000001001100110100001010110011000 +010001111111011100101110000011001 +100100111000101101000111101101111 +000111111100011111001010101110010 +101100010000010011110111001100000 +110111100001110000000111001000110 +100000111011110001010010111101111 +100001001100100100000001011100111 +001010101111101000111000011010011 +001100100011110001101101011100001 +110011001011110111111010101011000 +001010101110010010101100010101011 +001011011000010110110100110011000 +100011000011110110000010011111001 +000000000000110010110000110100111 +011111111011111010001101110100111 +110111111010101011000001000111100 +000001110110011011000111010101001 +000100000010101001000010001001110 +101110100010010110111011001111000 +100010111010000000011110111011000 +001100110100101010000010001110111 +110110010011101011100011010101010 +101100000100011110000001100101010 +111010000000011001011010011001000 +010010011011000101111100000011101 +100110101101011111001111001110000 +110101100011010100011110000101111 +010101111010000101011010011101110 +111101100011110100100111000001110 +100010000000001101010110011111000 +100111010010001100100010100100010 +011100110101111010100111101001011 +\N +001111101101000110000010001110011 +101110110000010100001000101100111 +101111110011010100111101100101001 +111111110011101011000110011001101 +110101100100010100100100010100001 +010101010000111001010001010000000 +101010010110111010011100011011110 +100010111111110000001110001101010 +001000110001101110010110101001001 +010111000111001000101001111111000 +100100101011001111001110100110110 +011101001101101000110010001010101 +001110011000100101001010011111010 +001000011101010010110111010011100 +111100110110000000101101101001010 +110010101010000111001010001010000 +000000011011110100001110110011000 +101010001110110100100100010101100 +101000101001111010111000100011100 +001000001100111000111101100111000 +000001110011111011001111100000001 +011110111001011000111101100010010 +100110110110010010111110111000110 +111101011010111101000001011111111 +010000111110010011010001110000001 +011110111100111001011010001000000 +101001100100011101111011100000011 +000011110010111110000000110001011 +000101111011100100100100101011000 +011101110111011011001011110010100 +011000110100101100001111010111110 +010011000000011011111100101010111 +100000101101101110000010010111111 +000111110100010011110010011000001 +001010001001110110011100110000001 +010000001011001001101111111111000 +000001000100011001011111111011111 +110111000101000100011101101011010 +010011111001010101101011001001000 +000100111100001010000010010010100 +011110101111101010100011000111111 +001011001101101000011011111000110 +011100100001001010011000001000101 +100101101100011111010100111001010 +111111100100101101001001111000101 +111110010011111001010101101011001 +011000011100001110110001001100100 +011011110101000001111110001000011 +111100000000110011001111011111000 +100101001011110100110011001110010 +100000101100011100111011000110001 +110010010110010001011101100100001 +110110010000000010100000101111100 +100011100010000101001101100010101 +001101111000011010100101010010101 +000100100011110001110101110010000 +100011110100101011111000110101100 +100011100011000011100000010001000 +100000110101110010101001001011000 +011110101101100100001000011100110 +101111111011011101111100110100000 +001110010111000001101001011110100 +000110011011101101011010101110110 +010101100101111111010001110001010 +000111100101111001111100010011010 +010110110001000101111111001101101 +010000111001001000011101111011001 +110100000110001011100110001111100 +000011110011110001011010111100001 +111011111100101011111100101000110 +\N +101000111010000101111111000111000 +000111000111001111011011001001001 diff --git a/contrib/btree_gist/data/cash.data b/contrib/btree_gist/data/cash.data new file mode 100644 index 0000000..385d01e --- /dev/null +++ b/contrib/btree_gist/data/cash.data @@ -0,0 +1,600 @@ +-166122.30 +-432746.26 +\N +-282683.84 +454558.76 +-446358.85 +374604.84 +-207772.37 +-447987.84 +326562.77 +-269813.11 +-191115.13 +-70048.27 +150896.02 +-476375.00 +-390399.77 +212177.03 +-204062.17 +97619.20 +310057.22 +-39178.09 +-369182.60 +-149433.85 +-410022.92 +-373445.06 +108900.38 +-357486.45 +380320.26 +\N +-483777.58 +-384690.86 +-115424.90 +-300012.64 +-261623.29 +-5423.17 +-159664.48 +-45458.63 +-379324.56 +280086.82 +491889.08 +117994.57 +-87318.07 +\N +-247918.60 +-407705.26 +290100.50 +-120064.52 +-61386.63 +-256384.21 +205928.38 +453688.97 +63433.87 +489091.31 +454693.57 +\N +-241552.75 +-18629.07 +399128.14 +421657.16 +\N +-153046.41 +\N +-259814.14 +351443.36 +112822.79 +207894.26 +-120775.66 +-454270.13 +-488281.40 +-332881.24 +\N +113333.51 +-311200.38 +355731.15 +155154.56 +469754.45 +-168023.72 +-479427.28 +243797.84 +323948.38 +425953.89 +-119177.18 +180678.00 +426571.91 +65894.05 +\N +-389103.14 +426557.67 +-403492.88 +292354.04 +195771.55 +-348533.49 +-2206.12 +425633.57 +-453156.39 +15382.26 +404980.85 +-401394.64 +\N +-241207.65 +342900.81 +-171471.67 +81593.45 +-458067.19 +-306441.87 +\N +-411424.46 +-318165.32 +30912.14 +\N +49720.90 +351963.89 +238010.43 +404837.38 +275021.74 +126672.84 +439889.24 +-324251.18 +133075.86 +\N +-198536.50 +206972.33 +170209.43 +-483750.81 +\N +327444.80 +75763.63 +9840.43 +15700.78 +-51623.99 +-218733.26 +-36204.85 +60701.28 +-190014.00 +150597.22 +13545.90 +-314080.96 +-427964.35 +15262.72 +461174.33 +169218.74 +-74740.49 +-384598.83 +-483728.30 +287537.47 +234918.04 +-433550.83 +-230734.17 +323698.65 +-146197.04 +-255563.61 +83532.71 +-469513.46 +-36592.36 +-73146.17 +285947.07 +150015.40 +\N +\N +-209659.65 +355722.96 +243539.28 +-32803.88 +477435.65 +\N +417338.19 +\N +261176.47 +267675.86 +-229013.85 +-116379.58 +-476925.33 +-20226.29 +-143918.96 +143456.45 +306561.97 +290244.64 +119367.95 +252541.23 +-345895.39 +163329.59 +-113415.56 +-444697.34 +406232.17 +\N +-100528.56 +-29727.60 +-432245.57 +-78154.99 +-40228.56 +388482.70 +-360892.31 +397567.58 +-61500.50 +197420.99 +-53405.45 +-10035.31 +307734.63 +-476264.93 +-187896.84 +74967.90 +-96352.04 +-204654.09 +-314590.02 +-498658.17 +\N +459916.44 +-294815.05 +20507.27 +\N +473415.90 +150774.51 +185491.97 +-74069.01 +\N +46254.06 +-367453.99 +-168238.39 +-329399.97 +359048.54 +422343.40 +-380964.05 +-470561.40 +496663.18 +380409.42 +44918.95 +324580.02 +479079.72 +177174.87 +\N +457126.55 +-112441.99 +-430676.25 +-135129.13 +336449.85 +487338.40 +7167.97 +-1800.51 +-291559.23 +304700.54 +-120904.61 +114795.52 +-430214.95 +408084.32 +-191474.36 +450118.77 +-352847.81 +437584.98 +156887.65 +\N +-342586.53 +-79521.47 +190267.42 +463657.84 +-405475.24 +151640.70 +-415959.15 +107777.66 +285276.61 +341585.38 +-388847.32 +\N +-18905.90 +\N +-51094.80 +-398920.32 +-86554.74 +-239996.08 +-159324.69 +98208.93 +127700.52 +495535.34 +344071.85 +348527.75 +-159520.00 +\N +341431.83 +33083.75 +-391284.15 +-192247.31 +-472981.85 +-205808.33 +-138646.73 +\N +\N +-310383.84 +-120621.38 +-67352.75 +434226.84 +460706.11 +-447900.16 +21469.25 +\N +218925.44 +-413275.69 +-207067.87 +39712.27 +67008.72 +456794.17 +-379796.06 +261767.80 +-466546.12 +-305730.53 +\N +-364597.47 +\N +458787.41 +81602.89 +-271359.05 +-361870.59 +-28626.33 +481330.97 +-454201.68 +\N +-287344.91 +-321038.68 +-449334.66 +-327779.24 +488133.53 +-329401.54 +316435.73 +60517.74 +-233468.01 +354078.72 +475270.56 +-276973.48 +2820.02 +-305523.48 +-119945.40 +-29204.15 +11065.46 +\N +\N +-349221.53 +402110.01 +-454995.32 +-830.00 +-463136.68 +\N +-300999.19 +370635.37 +-292020.51 +-239004.63 +340136.68 +-262815.89 +-184908.59 +\N +\N +141849.58 +-498941.55 +95873.74 +-285016.93 +-107089.11 +-13721.30 +457191.81 +155699.77 +86327.14 +395889.04 +-229107.82 +324853.91 +-498107.17 +386767.59 +219841.13 +-27583.14 +-149702.20 +146393.57 +-437989.04 +159841.53 +32498.50 +396403.30 +-315063.83 +\N +22649.64 +215343.21 +-175059.30 +-1847.18 +102497.28 +-247295.07 +332109.98 +-235782.85 +-295096.68 +\N +498125.83 +-333733.57 +-433530.70 +449518.21 +316400.65 +280480.98 +180453.94 +457876.49 +412833.95 +428460.60 +-10056.74 +-214948.53 +37814.95 +102477.82 +-225564.43 +-92130.07 +-155741.02 +78450.91 +343105.39 +-130527.09 +33079.19 +329362.42 +200577.60 +212415.40 +-311348.62 +-21477.69 +333801.57 +-353712.01 +-433106.23 +-26081.60 +\N +-163820.36 +151893.43 +205173.27 +-393163.22 +277938.44 +-276107.66 +-304649.71 +171386.20 +-306944.28 +370017.46 +249675.98 +-72023.48 +-372187.26 +-238104.04 +354749.41 +389572.21 +365556.59 +235734.34 +\N +-280573.81 +128725.64 +71656.14 +400415.05 +-130616.30 +244866.96 +-415742.86 +-211304.73 +-267780.95 +-425028.29 +170832.02 +253488.32 +193520.19 +-25218.72 +-277658.68 +-167409.34 +-474770.31 +74591.72 +\N +366618.43 +-171394.63 +329032.65 +-328557.90 +211902.62 +60210.12 +178715.93 +\N +-456832.44 +344825.40 +64195.06 +-370332.57 +155903.15 +-265256.14 +15323.04 +\N +233809.17 +411862.69 +6551.58 +-461516.27 +420681.92 +233340.82 +-373891.60 +440798.68 +-319872.00 +435051.22 +377502.70 +197215.84 +273887.91 +-360415.44 +-41466.42 +-335436.28 +441898.09 +1302.43 +144990.34 +188585.87 +\N +174623.04 +322047.54 +230563.87 +-300142.22 +-120404.31 +21472.79 +444194.03 +80999.42 +83236.09 +-414005.44 +-181501.32 +48402.05 +181956.91 +-261939.44 +-155431.06 +388392.94 +337512.20 +-492902.69 +\N +481390.20 +\N +494812.78 +477359.18 +\N +208828.94 +-51946.00 +378432.41 +137447.10 +-235678.90 +-260524.65 +286759.89 +86014.42 +303893.81 +-185836.92 +-339715.80 +474384.49 +-487805.30 +\N +-135660.84 +\N +-12158.99 +-24671.78 +104450.53 +\N +-201014.92 +-430860.23 +-132855.90 +-339856.08 +431791.82 +406070.27 +-80184.35 +-330535.00 +371020.10 +446960.92 +-461880.13 +-399502.34 +221025.82 +-332205.06 +-394278.43 +-361844.93 +\N +35170.25 +466405.94 +124030.12 +-412309.14 +\N +-351146.89 +51070.28 +-322829.73 +233996.37 +482796.36 +-355095.23 +-489800.21 +21915.01 +282777.96 +169811.79 +301306.60 +\N +-399859.75 +154814.04 +65509.24 +27086.81 +31231.96 +-304619.93 +494051.91 +-474057.76 +-263425.16 +6217.86 +-341118.74 +\N +-306167.25 +410631.12 +-232238.14 +-316015.14 +-61724.14 +\N +176961.97 +277381.68 +190797.28 +-457747.77 +-449873.37 +-484344.98 +-367413.81 +-43132.61 +121522.02 +87962.33 +\N +370495.18 +191540.22 +-76890.93 +-232322.04 +-111047.08 diff --git a/contrib/btree_gist/data/char.data b/contrib/btree_gist/data/char.data new file mode 100644 index 0000000..99bb6ab --- /dev/null +++ b/contrib/btree_gist/data/char.data @@ -0,0 +1,1000 @@ +b026324c6904b2a9cb4b88d6d +26ab0db90d72e28ad0ba1e22ee +6d7fce9fe +48a24b70a0b376 +1dcc +9ae0ea9 +84bc3da1b3e33 +c30f7472766d25af1dc80 +7c5aba41f53293b712fd +3 +166d77ac1b46a1ec38aa +2737 +aa6ed9e0f26a6eba784aae8267df19 +3677643294 +8c9eb6 +5b6b41ed9b343fed9cd05a66d366 +4d095eeac8ed659b1ce69dcef32ed0 +cf4278314ef8e +3bb50ff8eeb +dbbf82208 +fe9d26c3e62 +2fc57d6f63a9ee7e2f21a26fa5 +2a53da1a6fb +7c67493bd +2a52a5e65fc3c43f409550dfa +b0771132ab2531a40c99413 +66a7c1 +5 + +d5b4c7d9b06b60a784 +4f89 +bb743fc2a7213949f2 +4fbafd6948b6529caa2b78e476359 +fd1bc138d22 +64 +fa84f696e31d07f55cd45cc3c +87aa6 +bda81ba88c634b46394 +59885ebc737617addaaf0cb809 +90e2a51705594d033a3a +21fa2e +50a2fabfdd276f57 +f0287f33e +e76 +93e +d3a57c7e953913944c760093574695 +4a5c26d88c5 +08c61f3fd48f12fa7c88a +a75f5a8337c6699916182 +6eb5cefde6fcb8463cea70880 +1aa55 +7efd8e +c92841e00db +2d999528ef1dd9ae433698abf3fe7f43 +8d7e35631f8 +a074c5929fb8088 +ec8b36fb3489 +f0810a +6a +ecf27a776cdfc +1153ebfe1f3 +9a01df2f09a7bf076c0013 +d +9ca +767abe +73b4c20 +b21dfa3fea +59 +105be3ebd0677ec739afd851a6d8 +30b00ce4c04ddd6 +721327bfc0e276a87156 +8faff61bc119 +f634226e +1ff1 +9f +\N +1709106f7c5dbb0539104f4ea3c17a7 +2b44a59db15a3ee2f1605ac82b028 +46107b341ed115c03ac287f00 +54a24082cfebcd031a +cea4eca +37a9aea1b +a114f532e70502 +60f3db995d0676b576 +091b847d9660c +d02a55da8edcc7ec95a59 +db0aa8bee7afe5a6e363ddcd890 +071 +9e01624ab7743bcdbd8cb316 +4b1709eb0990e993c3125c15 +1b28e946f4a8ffd5bdf939779c420 +80ad60f95 +ed31ca2c02fe2af071ee0089 +3368d7171580c61644211e59574674b +c1cc2eeb27a86f85032b21 +9672a5e9c09fb71edf28 +27e4d3594a232b37951be232 +90fafcc60c7ee9f7a1 +18be9375e5a +b68495714b0e1cad8ebaa1599766a94 +\N +919d117956d3135 +cf6a52053ff904bca9d96f +5aa8301da6367 +ff7f2c85af133d +929ad9494d911e47cd54 +4df9699916 +48e3b +0fa41cbcef9d3f +f9926b3 +ca4047ce3d85454b067b93 +2fe51daae840593fb0f4076 +1181c1834012245d785120e350 +f3527f99 +754ee2a8de2d24e4e7 +83050114704e61f1c58d81d9b607 +980327c +0a5e +969049573085c71a5d6dc034e34b56 +12fc5425 +353a +617119c2d67402b +83de9f8ad800dc61db78100 +87ff3a697a3847ea7f3d +ba1f2511fc30 +df8b712c4fe20a0df93381966 +f98 +f83be66 +52ee216e7ea72db74e87cc1 +650a1c9c9baa20730b4fcfdbe +221a057e91928a3651f31d37 + +3be +e051e54a58c467f7e3e23e648bf7ab8 +02e6b43d34792 +7162e6c8 +615010a6 +be8032a3ea812eeb288df3a +557ff88fbe890cf23ab4c4b6526ebd +26e41e2047e361fd54e4d19ec3 +6067e932002 +f52f16 +3c71a3f3482184ceca06acb7859 +b17bf99d69b88017 +f498cc +8cf478ccdecd74e358a73857922d0bc +95a283596833b3edcd +9ae1400 +fca +e6d604c19ab3dad +\N +b +176e +409cd9f3 +0f0254a +699598531905f632234819bfa19c34 +f9c12 +df05072 +9f430be862c6c636d25 +2 +dc35b9fd881cc59bf54338af5 +7 +52154e9782f4ab05f7f77fc4abe6161 +cd3164cb1a8780dd +0c0a5b8 +c5bb33d902ffd764f88adb1036c +e2f06df03efbe62eae471 +12fd838288a9836dcb33694479b +31c76c1c43008d0a9d396 +027f19cca4a7119da720f7f60314ce +63cf7c8db392ec220067 +a187f54f5661d23769a5ab76651d1f8f +36f3 +2 +21b97fc756c8732ba5cbf021792257 +3d1108469b16342a97c5b60b3 +41075c479e3066c +261104cbe0eceac00eaf4bf5d +ed6 +edeaea17b7bb5f989e8879a33c11 +7b7731085d04d325b618f8f83281d5e +f584bd6f9cff10166a302a2ab5bc6e7 +e42002e140b29fc4 +8bd50a3a0da6 +993647e71651a205aba +948cd06ca76467 +3b9be5cbb65a3 +ae8d333327fdf610b2e985 +1e1da348199896d5d +0372c098401a1 +e6ce069c60d8e681ccd45b06ff3d47ad +34c6e1feaf7f5084f3014d5d11fb72 +bd918538adde6 +035032ee8 +6be7de648b +31 +939444082f2f746b655 +6f3898aad606 +3bcd6e8775 +cb +5321951a8 +\N +053ade8bc0514fd9f +c1ba58b05f6245f221ad653 +1454 +b6e693b66d2003e1d08cb4d +e7d14fa651db7754aff22716bfccb +cd0a54e70051990d13f1fec +1166083fc +1041ba7e06b +076decdd037ccb810d0e9e1756a9 +7c6139e8fb296b24 +cbb8413057f9176473225d +301416f843b954c1f +49a6957c6e2e1c5ce89cde8898949 +1ad002f8a +6f36dfd82a1b64f6 +f +c5db628ee33ef57f9e6aa +8f9654eb7b0c528ed7edc173b692173e +c64ee80b +da4f2c32a51ddfa1 +545d8fdb508d46e +f5d8eac62167a471f95928c +48341ed4f1304fb01623d8f456 +348bd3ce10ec0 +9b779599da6 +f +2485938 +4a6d02b7fc61f162e24ea +dae34b +a84fb2 +55fc63933ba0c92102a8e +8226197b889d86f722471772777cc +fac87b8618ebb0dc9ec3f1b557 +3d26e13f5daf5e +9f3d9739b11c2a4b08ea +e4 +bcb35cddc47f3df844ff2 +caec6c5b9f4424ac0b44c2cf +427e8576c702d4d715 +4f61029d752be4d45c5e +938a35 +ffbfc1313c9c85 +3482bfb20c3f103718e +214311510e3d55d0291ad717f +909596ec6cc7db +16b70e +1471e2c8fff7ddcce1acd0210c +20007c50aa9258083faf59d69a0 +4479235f75efaad02357cbff +\N +\N +fbaa030eee9a34cefd5248d7c9005 +4d685096123bcc72d0923df5c +3c0efa1ba676ecbc802c3717f291ee +bdeaa2482 +60ec2d50e99cbb811e8 +90922c +64dbc39ab9cf +de030a3d4e727eb9 +26b4cb0930a +ac6a20237 +ee06d5a17b757b231d004946 +aeb75a20c5efa12e33eb54f1f7599 +0c4a96bf0bc4 +2bf1686588c741e0f407 +9f0ed6cee42549a57 +6b7e26a +8c +259a568c9e5262afa3bb020 +d9296b +6f6fcb8d7 +457126a29df4c8 +cdd52d64d4c86b2807dfd31c5ee0 +d4d67ff03c419e3fafc227628690 +453 +2c028a63bb4a9b99dc57e +b912d22e1bdb0027532bb318 +a3ab82e89ac30fdc459c5d +bcd69f8c3 +94 +07ca93ea45d55d28894b8664 +3910a4fc69883 +fc28261e2becf14ad69ba +af69b1990 +5dbd27ed12e6ca549c958d61db5 +9db1725416 +70d37da46913c0157ee +33e2 +5131e6710ad926457f97 +849c49cb79d556969520a7ba510fa7 +ff4da50c05473ef35e9f3442d39f + +4693b22f920e040c716c +6c2a40def9f5197fdf4a9fbb98 +bc88b78c1fca882c19a55bb725134e +352ad14d71a6069544a8592da +a43e268d90bf08407 +d70d0dd90a6c3 +6ba01cd31a75dd3cab2b6800a7e +5a592088ddbd5c96f25e13edd9 +fd1a71f57514f3d96aab5b +4268c65769504e17a0bcd91407e23 +3de +62b594 +1445f5c59eb6ef023569de +06b904260b0d751caf00 +31b0 +c687a39f +d31ba3c1c +828007765429cc8470834c483ab625 +64a +4eaed852e6857e6c196f20cfa49 +2dd746 +fe +8373fa500 +39 +f1bbcefb43f8731a660091a +642606e93992a316419e +0d96f49fdbb +47bcdd11e1cd38abf97 +098ddacdd558720b +0116a06b76 +509a69c52a4bf +6b23c0ac4415 +9492fe88f263d58e0b686885e8c9 +5c80dc6aeb95 +2ab5372e91b61384741a2 +\N +36ef14 +7c1b3b869434ddf685bc503e3067 +2ba9cf6 +9a215d19e54bc4b2282e30c33214e3 +c2cff429a10edd8 +e049b6ef70e237d8fa +96e6cdd58a6ef8e66f5188835 +080002b079e1c8f0c993 +aab4cdfa017 +40b134a +7dbfc1a44c7463d842d9adc6481 +8a318bde4768cb68f23fc193354 +a9700592 +d1d39407e2dc464252ef76d6f +7488b677139de1cfcff7c7 +30d310 +9ac1dce6537ab +125dca018389717c78efafb +7b95e765 +ca19fff8824c2 +71aeb19c +4692d489b0638e49682df4f46dacd3c +f37053cfdff777709610fe4e +51c36ccac +2eb2c961c1cbf6 +\N +cf8d7b68cb9a2f36 +7bbedb4ae7 +06ec46c55611a466eb7e3edcc009ca6 +e +5ed9cd0ea5a4e55d601027c56a + +64cacf3a42afc +90e63000c34506993345355640 +79bce +173bb7 +c5 +574ea7c921cb0f25 +089d56d16dff24f336e4740 +6870470f1f9afcb4f7c56c9f +b97e117fc965 +7013029 +e48f6dd481 +7d00e1e227beef84a9 +904d4c34241f +cb5c0f14 +3a8a70 +f51a73164e92052fbb53b4cc2f1fed +3c3fecaa0270175 +2521ef03594 +fa05756812648f450fb +13c2f +b39a0729d6182e9 +15b5ea204fe73 +d8991afd72d21acd188df1 +a29fff57ab897338 +de549b3ed5a024534c007125c +2fcf3e5c3e3 +7427b6daec5c3f +473 +8 +a5d9 +840410976ac2eeab58e1ca8bf46c2b7 +1db9cc85a336f1291ea19922 +db808f3548cda91 +2e379ce80af12bd7ed56d0338c +a +ea67a7c847f6620fc894f0ba10044 +0e +52e97d975af7201d8 +d95e6f08184d8ff +19762476fa +42f278f3534f3f2be0abaed71 +f0aba11835e4e1d94 +e8534cf677046eafb8f5f761865 +ffbee273c7bb +2bb77f6e780 +c77e81851c491 +e +a9f45d765b01a030d5d317 +ff7345a22bc360 +c87363ba121297b063e83 +13ea32e9618d +40304f6c2a7e92c1c66ff4208e +a781b4a21419abfdf5eb467e4d48908 +8a65656e514b2b3ef8f86310aaf85 +4 +90b7b2862e3dbc8f0eef3dfc6075bfa +eb94a1c +a58abb5def4fa43840e6e2716 +260e6eaebb +42415d712bf83944dcd1204e +305254fc3b849150b5 +5bbd7f8471dcd3621 +2ae0548115a250 +0c1988e9 +76f98bef45639b7 +0d5a28f01dc +b71 +c046576faa4d49eff8 +\N +c1e8d01c +10c86c457ea050455a742da4f8 +ea7676af85c71c7eeca635 +6a07137227404d +a4 +7186172 +8150f31c9a15401c +f1bb9057a9938bfa +22b482be08f424ec4 +21daea994293589 +15bff393f6b17fef24786dd6f9 +d5a2d +4b3b5dd9370543e +b4a93b2ac4341945d06 +d384447812e0 +4e3c97e9b8f7 +f7d4d644b2a1d373 +5102c +b9531f725674b28 +1aa16e7e34285797c1439 +51aa762ea14b40fb8876c887eea6 +45a62d3d5d3e946250904697486591 +b3f1a8 +243524767bf846d +\N +8 +95 +45a922872 +dd2497eb1e3da8d513d2 +7821db9e14d4f +24c4f085de60d7c0c6ea3fc6bc +e4c9f8c68596d7d +afd6c8cb0f2516b87f24bbd8 +61d2e457c70949 +d2d362cdc657 +3605f9d27fd6d72 +32de91d66fe5bf537530 +859e1a08b65 +9b5a55f +4116cda9fddeb843964002 +e81f3b2c0ca566ad3dbbc6e234 +0d3b1d54 +10c440be5c0bca95 +7dad841f +a61f041967972e805ccfee55c +deee9cc16e92ab197 +7627554073c1f56b9e +21bebcbfd2e2282f84 +7b121a83eeb91db8 +\N +4668b2019ebff30b970ccde7026e779 +2aa +eeca4d01996bdc8af7e4dbd01 + +a3431c0758a8c +52c07a135df1dda388 +6ee649b5a +c4884 +dab3abb06371c8a32dda2231e6 +e0 +92 +8fdb98 +cfbb1 +96acd3e9 +73be4a4f277862904a52 +fa +051b8f9c0d6d2b2 +bde +23d51c87b6c931d314c88e44edcbc06 +e822a0497153 +1963a88d14ac0c9b7fe2 +3ffaff39b37650c5cf +dc0 +aed3d3de6c6d9 +2347412d3332140012f +0 +\N +7b311463334cd1a +973a0eb +d1cc8f07f56a62d1386a +905f2bb7e8852fb96cb9aeff95 +b026324c6904b2a9cb4b88d6d +26ab0db90d72e28ad0ba1e22ee +6d7fce9fe +48a24b70a0b376 +1dcc +9ae0ea9 +84bc3da1b3e33 +c30f7472766d25af1dc80 +7c5aba41f53293b712fd +3 +166d77ac1b46a1ec38aa +b026324c6904b2a9cb4b88d6d +26ab0db90d72e28ad0ba1e22ee +6d7fce9fe +48a24b70a0b376 +1dcc +9ae0ea9 +84bc3da1b3e33 +c30f7472766d25af1dc80 +7c5aba41f53293b712fd +3 +166d77ac1b46a1ec38aa + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/contrib/btree_gist/data/date.data b/contrib/btree_gist/data/date.data new file mode 100644 index 0000000..69221b4 --- /dev/null +++ b/contrib/btree_gist/data/date.data @@ -0,0 +1,600 @@ +2019-11-22 +1995-05-20 +1989-04-12 +\N +2023-10-21 +2028-11-27 +2024-05-24 +2018-08-31 +1988-07-16 +\N +2019-05-21 +1972-12-12 +1975-05-07 +2022-08-11 +1975-06-27 +2004-10-26 +1983-05-14 +2015-06-20 +1978-02-17 +\N +1970-12-04 +1977-03-22 +2032-10-28 +2004-03-02 +1992-10-29 +2021-05-05 +2025-06-25 +2036-07-15 +1981-03-10 +2012-12-04 +1996-02-02 +1992-12-31 +2003-02-03 +2008-12-15 +1994-11-19 +2036-09-20 +2034-10-21 +2019-11-16 +1995-01-23 +1974-10-11 +2027-02-26 +2027-08-08 +2037-08-30 +2026-01-08 +2023-09-18 +2012-03-07 +2011-08-29 +1979-11-06 +2033-09-25 +1986-06-08 +2020-01-13 +2015-09-19 +2035-11-16 +1985-11-12 +2002-05-26 +2002-01-30 +1980-01-26 +2037-03-23 +2016-02-23 +2023-04-21 +2033-04-11 +1985-09-09 +1993-01-29 +2015-06-28 +2036-04-06 +2031-12-08 +2014-02-26 +1994-01-23 +2019-01-27 +1978-08-01 +1979-05-21 +2022-12-12 +\N +\N +2007-10-16 +\N +2037-05-17 +2034-08-14 +2014-12-20 +2033-03-13 +2010-10-03 +\N +1992-12-23 +2029-05-15 +1993-07-17 +2007-11-06 +2024-10-22 +2019-03-02 +2026-07-24 +1973-03-29 +2006-06-02 +2032-06-11 +1990-01-28 +2019-06-16 +1970-04-21 +2012-09-17 +1993-10-06 +1993-02-24 +2014-12-07 +2018-09-17 +2015-05-22 +1983-01-19 +1978-11-08 +\N +2021-06-01 +1970-11-19 +\N +2030-06-12 +2035-08-11 +2021-01-31 +\N +1996-06-25 +1974-11-28 +1989-04-28 +1998-07-17 +2029-09-14 +2010-01-06 +2013-05-04 +\N +2023-10-03 +1998-02-06 +1984-07-16 +2008-01-11 +2015-06-23 +2026-04-02 +2021-11-26 +2012-07-09 +1975-01-07 +2022-12-04 +2013-01-22 +2001-02-13 +2001-11-20 +2008-12-27 +2030-07-05 +1970-07-22 +2037-07-11 +2034-12-24 +2022-04-04 +2018-03-24 +2037-03-25 +1972-06-24 +2034-08-15 +\N +2030-01-12 +2000-08-15 +\N +2034-07-25 +2030-04-06 +2003-08-22 +2012-04-17 +\N +1992-11-30 +2017-03-31 +2004-06-19 +1974-02-07 +1992-11-02 +2006-07-03 +2030-09-03 +1989-12-15 +1992-05-03 +1981-05-05 +1983-06-04 +2010-08-13 +\N +2022-06-15 +2011-03-10 +1973-11-06 +1998-03-22 +1992-07-20 +2022-01-15 +2022-05-03 +1972-06-08 +1976-10-27 +2023-12-13 +2027-08-01 +2009-05-04 +2021-03-19 +2025-04-09 +1988-07-28 +2023-07-31 +2003-07-25 +\N +1995-12-12 +1992-04-19 +1997-08-20 +2028-01-13 +1980-04-18 +\N +2030-03-08 +2000-03-22 +1987-03-17 +2008-03-10 +1982-04-02 +1970-01-29 +2032-03-28 +1991-10-03 +\N +\N +\N +2035-07-02 +1988-11-27 +2034-08-29 +2004-11-29 +\N +2013-08-28 +1997-04-06 +1994-10-12 +2027-06-18 +1971-01-10 +2035-02-23 +2036-10-25 +2033-06-29 +\N +2028-07-29 +2003-03-18 +1994-11-29 +2001-10-08 +2019-03-10 +2022-05-19 +1971-07-13 +1979-07-25 +1980-11-27 +2030-02-20 +1973-01-02 +1992-12-20 +2034-03-04 +\N +2036-11-27 +\N +2023-09-22 +2023-07-13 +1996-02-13 +1974-02-11 +1996-08-07 +1998-06-13 +2035-04-21 +1996-03-04 +2019-05-04 +2024-06-01 +2007-02-20 +2003-07-29 +2000-07-13 +2011-09-08 +2019-06-10 +1975-02-25 +2002-01-16 +\N +1986-04-08 +1986-03-08 +2019-06-21 +1988-09-19 +2035-11-30 +1986-11-27 +2037-03-10 +2030-07-15 +1988-06-29 +\N +1980-04-23 +2020-01-19 +2012-09-14 +1983-12-28 +1987-02-10 +2029-09-21 +1972-03-12 +2035-11-20 +1996-10-25 +1981-02-05 +2031-09-10 +1986-04-24 +1987-04-26 +2017-06-10 +1980-07-26 +2009-10-18 +1981-05-24 +2026-07-17 +2015-09-30 +2032-05-02 +1987-08-17 +2034-10-20 +2008-11-20 +1986-11-06 +1980-04-06 +1982-11-12 +1975-01-24 +2015-04-25 +1980-03-14 +1998-04-07 +2020-12-16 +2004-10-31 +1975-02-26 +2024-10-29 +1974-10-29 +1986-09-21 +2037-11-06 +\N +1979-06-02 +2001-06-28 +\N +2024-10-14 +2031-03-22 +1983-11-27 +1989-01-01 +\N +2037-03-05 +2002-12-28 +\N +2031-12-20 +2002-08-30 +1997-11-16 +2023-07-17 +2010-04-02 +2019-09-21 +1978-03-04 +1992-11-08 +2002-02-11 +2012-06-06 +2012-11-23 +1997-09-27 +1972-12-18 +1985-10-25 +2028-09-29 +1976-03-31 +1996-06-26 +2014-07-06 +2032-05-21 +2018-12-18 +\N +1974-06-02 +\N +2024-09-29 +1996-07-03 +1973-02-11 +2019-12-02 +2035-09-04 +2008-10-10 +2018-05-16 +2020-04-17 +2030-05-04 +2002-10-27 +2036-03-04 +2002-10-29 +2000-06-22 +1981-01-01 +2001-12-31 +2003-09-25 +2020-12-07 +2016-11-04 +2026-02-23 +1990-12-16 +2033-10-15 +2003-07-29 +1998-10-09 +2006-04-02 +1970-06-06 +2015-02-06 +2004-06-23 +2015-12-08 +2024-06-26 +1997-11-07 +2023-05-09 +1992-11-16 +2016-04-17 +1996-11-09 +2010-09-12 +2012-10-17 +\N +1998-07-19 +1973-11-11 +1992-11-15 +2032-04-22 +2031-09-14 +2005-03-25 +1993-03-17 +2004-03-01 +2009-10-06 +\N +1993-06-07 +1994-07-31 +1987-08-07 +2034-05-01 +2025-06-19 +2019-10-13 +1977-03-25 +1978-01-16 +2003-09-29 +2002-04-07 +2024-01-12 +1984-08-29 +2036-08-16 +1972-05-14 +2019-01-24 +2009-12-19 +1982-07-26 +2012-01-22 +1983-07-22 +1978-05-27 +1974-04-02 +2008-02-15 +2003-01-14 +1989-03-30 +2009-12-14 +2030-07-05 +2032-07-22 +2016-05-17 +2031-07-02 +\N +1980-07-28 +2031-09-06 +1975-01-20 +2019-05-05 +2025-05-02 +2001-12-27 +1991-09-27 +2021-12-14 +\N +2027-03-24 +2009-01-07 +1985-02-04 +\N +\N +1996-12-23 +2012-05-22 +1980-02-29 +2018-06-14 +1981-07-04 +1993-04-25 +2027-03-09 +1981-01-10 +\N +1974-06-16 +1985-10-15 +1988-01-11 +\N +1997-03-15 +1982-02-26 +1991-05-13 +2015-09-03 +\N +1987-06-05 +1971-03-29 +2002-03-28 +2032-03-25 +1983-07-23 +\N +1999-01-15 +2014-01-31 +2021-09-02 +1999-01-02 +2001-03-24 +2002-01-21 +2007-08-06 +\N +2032-09-07 +1984-11-22 +2035-06-18 +1994-07-29 +2023-04-20 +2010-02-17 +2014-08-23 +2017-02-08 +2036-10-24 +1994-11-14 +1979-04-19 +1973-10-09 +1999-01-17 +2012-07-08 +2012-12-03 +1980-11-22 +2002-02-28 +\N +\N +2023-03-01 +\N +1981-05-13 +2026-01-29 +2034-02-14 +2031-09-22 +1986-11-13 +2031-10-25 +2010-10-13 +2036-09-11 +2027-09-30 +\N +1990-07-28 +2001-05-05 +2029-01-10 +1972-10-09 +2012-03-25 +1987-04-06 +1998-06-04 +\N +2008-12-26 +\N +1979-04-23 +2010-01-16 +1982-07-23 +2013-08-21 +1982-12-23 +1997-04-03 +1986-02-20 +2034-09-08 +\N +1999-05-14 +1989-11-18 +1987-09-17 +\N +1978-05-03 +2005-05-22 +2001-02-11 +1980-07-28 +1984-04-11 +2010-06-02 +2023-09-05 +2020-12-29 +1997-06-06 +2005-10-01 +2023-01-17 +2013-04-27 +2018-05-23 +2022-11-23 +1971-05-09 +1997-12-05 +2008-08-22 +2025-05-23 +1989-02-18 +\N +2035-08-21 +1995-02-09 +1994-11-28 +1980-07-20 +1998-09-02 +1993-01-20 +1979-12-21 +2010-03-05 +\N +1989-01-07 +2015-10-09 +2006-08-23 +\N +2003-04-27 +2029-03-21 +2030-09-08 +2022-05-05 +1993-10-22 +2031-04-01 +2015-03-10 +1988-12-08 +2004-07-07 +1978-01-11 +2013-09-28 +2030-02-25 +2036-09-15 +2019-07-16 +2034-09-05 +2003-11-07 +2000-10-02 +2002-09-19 +2016-03-16 +1986-02-06 +2018-07-07 +1972-02-07 +2001-05-06 +1996-10-05 +1995-12-26 +1990-05-13 +1983-03-10 +2011-08-03 +2029-01-26 +2022-04-24 +1973-09-03 +2002-09-19 +1982-04-30 +2023-11-30 +1992-05-13 +\N +1986-05-11 +1976-12-31 +2009-10-23 +2022-02-08 +1999-02-24 +2007-09-30 +1991-11-03 +1985-06-14 +1973-06-15 +1972-07-18 +2012-07-05 +1989-01-17 +1982-02-13 +1994-11-23 +2008-08-01 +2032-11-22 +1976-01-04 +2037-04-11 +2011-02-24 +1992-11-16 +2025-11-25 +2013-02-08 +\N +2002-05-13 +1983-10-15 diff --git a/contrib/btree_gist/data/enum.data b/contrib/btree_gist/data/enum.data new file mode 100644 index 0000000..d03bfce --- /dev/null +++ b/contrib/btree_gist/data/enum.data @@ -0,0 +1,595 @@ +r +v +i +b +r +\N +y +v +g +o +y +b +o +o +o +o +v +r +i +o +b +r +g +b +i +o +r +r +r +\N +o +b +v +y +o +\N +i +o +o +g +g +b +y +v +g +g +\N +v +g +i +i +\N +v +y +i +r +\N +r +\N +g +\N +g +\N +v +g +y +v +r +v +r +v +y +i +i +v +y +v +i +b +i +i +r +r +\N +\N +y +r +g +i +y +i +i +r +g +y +\N +i +o +r +y +y +g +o +o +g +y +r +g +v +r +i +r +i +r +y +v +b +i +o +r +\N +o +i +v +o +b +\N +b +g +y +o +v +b +i +v +v +o +y +i +i +i +g +b +b +g +r +i +y +o +\N +r +\N +i +i +g +v +o +y +y +o +i +b +r +y +y +o +g +g +g +\N +y +o +v +g +y +g +v +\N +i +o +v +b +b +\N +y +v +\N +v +\N +i +\N +r +b +r +o +r +b +o +g +i +r +b +g +g +y +b +b +g +y +g +v +v +b +\N +i +v +y +b +b +o +g +b +v +g +g +b +\N +y +r +r +b +\N +r +g +i +o +v +\N +o +r +b +o +b +i +\N +\N +y +b +y +\N +i +i +i +o +y +o +i +b +o +g +r +\N +b +y +\N +g +b +y +y +o +o +b +g +i +i +v +b +o +o +v +i +g +i +o +r +o +i +i +r +b +g +o +o +y +v +g +g +g +r +o +i +i +g +\N +o +v +b +b +v +i +g +y +i +i +g +r +y +i +b +\N +g +y +o +\N +i +i +b +v +o +b +v +r +g +o +v +v +y +r +v +g +\N +v +v +b +y +o +g +i +o +b +r +y +r +v +b +b +\N +i +v +y +r +b +i +y +g +\N +g +r +y +y +g +b +o +v +r +i +g +r +b +b +b +\N +y +y +y +i +o +r +g +g +i +y +g +y +v +o +o +g +\N +b +v +o +y +r +\N +o +i +g +\N +i +i +i +o +b +\N +\N +b +\N +v +v +r +\N +o +b +r +o +b +o +r +y +\N +r +i +b +b +y +v +r +g +r +r +\N +g +\N +v +v +y +r +o +r +o +i +o +\N +r +\N +i +v +b +v +\N +b +r +v +o +\N +i +r +b +g +o +\N +o +g +r +v +y +g +v +r +b +r +v +o +g +i +i +g +i +y +b +i +y +r +y +o +r +b +y +y +b +y +g +b +\N +r +g +b +o +y +o +g +r +g +b +\N +v +v +v +g +b +y +v +o +v +g +o +g +i +b +v +i +r +r +i +b +i +b +o +\N +\N +y +r +g +v +o +y +\N +g +v +o +b +v +v +\N +r +v +y +g +b +o +v +b +v +b +r +r +i +r +v +y +v +y +o +v +g +i +r +o +o +i +y +r +\N +y +r +b +y +y +\N +b +\N +\N +i +v diff --git a/contrib/btree_gist/data/float4.data b/contrib/btree_gist/data/float4.data new file mode 100644 index 0000000..947955e --- /dev/null +++ b/contrib/btree_gist/data/float4.data @@ -0,0 +1,600 @@ +3926.686551 +-3078.593513 +-1523.429224 +-669.684166 +234.904986 +2226.918930 +-4718.612498 +2093.397950 +-1914.453566 +4027.226232 +391.864393 +4525.522995 +-158.177421 +-4801.751557 +3410.161728 +2481.256122 +-1640.183123 +1611.826046 +-2448.451169 +-1845.197308 +2683.842745 +-3542.172810 +3089.066696 +-2517.697386 +1892.967423 +727.945774 +-3513.884856 +-179.0 +\N +-1469.088605 +-4739.206973 +145.945556 +4549.133936 +-4208.637634 +-1936.179384 +4602.395105 +-1804.145345 +2053.716787 +\N +1456.927004 +4702.396402 +3268.547085 +-745.573619 +4625.357450 +-4765.915573 +-2790.475971 +-3403.123686 +-2817.878573 +-3274.289481 +-2413.766411 +-1374.753772 +-1924.610286 +475.397257 +3510.523368 +3814.010913 +-1859.390939 +168.847235 +2264.721811 +-2223.366707 +-1753.785013 +-3945.658993 +-4315.231992 +2746.639442 +-2342.824418 +-1044.805914 +3584.727458 +-3822.565833 +-2102.212746 +\N +1818.932987 +-3585.541038 +1452.891425 +1165.643202 +2412.440259 +-1608.959230 +-2272.316845 +3352.859341 +\N +1067.661511 +373.127556 +2907.255277 +\N +\N +-4119.844655 +425.751771 +-4652.598253 +3178.567043 +-2664.539180 +-1099.284997 +-2144.177909 +1805.341405 +\N +2945.853662 +-3351.437225 +-4875.769736 +\N +-412.211551 +-3334.087165 +1695.085786 +2535.912119 +\N +374.050255 +-4771.851972 +2954.420418 +1929.919923 +-3434.967221 +\N +2700.864965 +-2783.682392 +4985.334217 +-2062.958207 +4153.150501 +3012.590980 +-3011.189139 +\N +2721.497588 +-4169.312617 +-64.988860 +-4188.005384 +1744.599224 +1067.803538 +-1660.431575 +2804.799493 +3088.508415 +-4646.231299 +4578.547883 +-294.892171 +-561.912989 +1867.265677 +11.839394 +582.688896 +1502.454824 +\N +\N +4301.881413 +\N +-2194.430268 +-614.422083 +-690.354777 +4779.886957 +4531.156281 +4944.867236 +3858.390189 +3506.107763 +-4894.456207 +\N +1322.857973 +2578.630265 +-2175.318379 +-4086.425476 +4630.773663 +-3800.461310 +3753.750072 +\N +647.435317 +\N +4110.477110 +514.193226 +-3441.902748 +2573.758703 +664.845479 +-384.002535 +2023.851111 +-4615.566879 +\N +521.022754 +446.504990 +-3517.434806 +\N +1710.468068 +-988.509024 +-93.124302 +-2974.066063 +-1466.562229 +4606.999513 +291.009348 +771.456014 +172.233984 +-1228.758016 +-1273.510068 +3472.468191 +3783.157877 +-260.342455 +-4133.938523 +-1558.345359 +818.740365 +2345.368051 +4818.590693 +\N +-152.159210 +1395.434275 +-3107.620263 +4746.555020 +-189.023868 +3178.467591 +4922.804367 +-4963.738942 +\N +-2933.352626 +-3894.560951 +-1721.494834 +\N +-2491.926382 +-1659.638708 +3626.190726 +-1804.918329 +455.648226 +2244.824659 +2443.616389 +1022.869542 +3580.157235 +3348.054857 +-1537.855671 +1607.360266 +-1692.376280 +2292.201299 +3400.898151 +1889.594163 +239.448960 +4596.602567 +766.064066 +-1906.189177 +752.355324 +-2388.240838 +248.493708 +-4383.772933 +-3099.040067 +4912.247853 +2740.401308 +1334.028196 +-6.110885 +4208.217412 +2685.419516 +1947.814527 +4270.682796 +746.828278 +917.931886 +\N +-1105.016263 +-406.957355 +-2023.670192 +-477.481347 +-1056.222565 +-4039.906966 +3609.872045 +-3297.475124 +1972.339566 +-1621.688887 +-1030.170236 +-4464.104576 +-2638.849336 +1175.210125 +-483.963827 +-3362.699658 +456.088565 +-4952.708059 +4982.336056 +801.148906 +-1533.282710 +-1739.269000 +\N +-4390.957509 +4222.786482 +-4279.669281 +\N +4937.803242 +\N +2036.653081 +3409.729758 +3247.885061 +817.041977 +-822.372779 +2189.003680 +-3551.808846 +325.503762 +-2688.361261 +3833.177084 +2890.005446 +1325.965340 +-4132.875092 +-3011.022842 +1666.958698 +-4889.208372 +-157.283687 +-1516.214021 +3080.057571 +-2355.486070 +-539.260584 +-453.194364 +3574.346313 +-1012.181736 +1419.900389 +-3090.709731 +-811.664223 +1598.174198 +-1224.255663 +-1394.494598 +\N +2972.381398 +220.199877 +3542.561032 +-2168.024176 +-3305.714558 +\N +1754.880537 +3633.414739 +729.945999 +-2427.865606 +1648.939232 +-495.744751 +108.475352 +513.797465 +-3036.007973 +-3596.329479 +-3672.066260 +2261.791098 +-2077.391440 +-4873.215449 +4907.530537 +-3355.449754 +-3356.602051 +1232.493090 +-2822.598325 +1335.803283 +-1816.035000 +-479.029122 +\N +\N +4116.023187 +-259.211424 +-1636.301636 +151.567927 +\N +615.774279 +4981.348277 +-4279.760471 +2122.969975 +2331.666647 +-1270.180538 +-2166.953835 +4085.841327 +2906.495024 +3656.341992 +2993.227550 +2151.115144 +-2275.655664 +-3203.291138 +2257.053474 +-4566.818042 +-4214.319326 +2730.795260 +-4194.037830 +116.563907 +-3036.016760 +1681.412271 +-3805.177421 +-1747.152073 +-4864.378627 +-3938.731704 +4232.011228 +20.740053 +-1645.529264 +2544.557875 +\N +4777.722624 +-3356.018294 +1307.984314 +-1166.544462 +-1620.147366 +-137.408513 +724.484001 +-1343.453124 +4804.629749 +4522.789567 +2328.926240 +-1317.294201 +-4298.136513 +3398.895482 +3464.478505 +4943.133318 +3232.351173 +2893.212860 +1198.575174 +1121.555146 +-3552.881646 +4365.806104 +\N +2352.417529 +\N +4680.141932 +-2668.895399 +-238.973845 +-285.805471 +-3520.289230 +4878.743007 +1780.984535 +2832.673354 +4298.407435 +\N +-1608.563991 +1684.308879 +4737.577396 +4101.170539 +\N +-1464.015649 +\N +-3738.782163 +-3621.216579 +2780.429035 +2384.467403 +\N +552.970942 +3547.166413 +4900.754164 +4495.504335 +1607.961290 +4286.663369 +988.747024 +-2356.908041 +-1623.399549 +3724.461980 +-1540.581932 +561.640885 +3054.001451 +2224.754615 +3311.427291 +\N +351.611318 +4176.146704 +-2049.963552 +2267.505572 +-4955.461980 +1276.636327 +-1508.073735 +-1598.198477 +1602.926844 +2157.874181 +1669.786780 +-3082.299418 +\N +-1788.620850 +2555.355424 +-4870.338212 +-2851.518662 +3882.485213 +4641.214218 +2506.994706 +\N +-1108.634810 +-4278.677501 +-2160.498210 +-806.103356 +\N +880.145694 +1368.632529 +-2048.461217 +2899.266336 +-870.758219 +-2863.581156 +\N +1682.631744 +3266.096445 +2626.991285 +1248.276847 +-4262.887118 +2777.053997 +1327.535555 +-426.769580 +-314.249841 +729.344234 +3891.552519 +-4918.473703 +4922.770997 +\N +2679.172460 +\N +4879.287118 +-4635.792221 +4496.176890 +2007.650308 +3821.565699 +-500.003884 +-1126.098170 +4487.603870 +3855.490996 +-56.857325 +1215.173530 +-1892.555336 +-1632.647536 +1942.954095 +64.593039 +-4396.942081 +-1643.806415 +363.886503 +3916.018470 +-2067.613754 +-1717.717134 +-3333.186669 +-3027.546004 +968.184544 +1210.732165 +2708.135698 +1052.369823 +-4434.389802 +-853.166476 +-1686.386083 +2647.478668 +2690.547401 +-4642.268889 +-3997.579827 +2927.765217 +3461.773129 +781.051482 +2525.672604 +3121.858727 +-2270.808321 +2873.250371 +\N +4843.809511 +-1187.515681 +\N +\N +3528.188564 +-3487.236154 +845.094270 +3843.943537 +-558.746078 +-2471.493491 +611.999359 +-3199.954144 +-4988.404294 +4145.897291 +-1803.093537 +2876.372318 +-2474.919272 +4497.979139 +4625.114016 +-2221.654210 +4501.765724 +130.449252 +4534.131102 +1415.347330 +-993.720547 +\N +3443.961678 +-4849.518817 +4573.353608 +4818.748920 +4330.041823 +3161.612855 +3607.737095 +-119.757296 +-1339.207751 +-331.384328 +2228.158823 +2697.192313 +-4775.355388 +-3594.790915 +-3397.374660 +3837.461611 +-4558.641468 +-1624.755387 +4430.022700 +-1940.296994 +4832.148761 +-2888.874695 +2894.719014 +2866.099508 +-1161.805185 +-4395.337603 +-1091.088679 +-819.707958 +4596.183826 +-1154.086625 +2249.981569 +2996.321776 +457.294320 +-66.348014 +-513.412089 +1125.862285 +\N +-4243.177180 +-291.472275 +\N +-2609.517713 +-2621.961719 +2269.398848 +-2249.532369 +4686.007011 +\N +4873.354365 +3895.563571 +-2282.372172 +3784.030075 +-3485.082555 +2354.903229 +\N +-2944.317869 +-2485.837190 +3776.108724 diff --git a/contrib/btree_gist/data/float8.data b/contrib/btree_gist/data/float8.data new file mode 100644 index 0000000..ff21226 --- /dev/null +++ b/contrib/btree_gist/data/float8.data @@ -0,0 +1,600 @@ +-39017.848619 +17104.680681 +-9885.090245 +-931.243017 +-29740.660628 +-14665.622294 +46069.995126 +2910.093476 +7714.560143 +1722.339844 +-12287.580158 +-12735.100679 +\N +37831.578771 +-2603.424551 +-41339.385226 +-15583.453591 +8187.403650 +\N +48185.906931 +34727.898466 +-1521.592099 +13954.342745 +-31076.202626 +47465.550200 +-1890.0 +31784.675914 +\N +\N +\N +-29333.526259 +-38945.609512 +-17214.948343 +6871.406388 +\N +-16596.387078 +36261.907260 +-18049.183287 +4556.482264 +22448.246587 +24436.163890 +10228.695423 +35801.572346 +\N +-15378.556710 +16073.602655 +-16923.762796 +22922.012989 +34008.981513 +18895.941632 +2394.489596 +45966.025673 +7660.640663 +-19061.891767 +7523.553240 +-23882.408381 +2484.937083 +\N +-30990.400669 +\N +27404.013079 +13340.281957 +-61.108847 +42082.174119 +26854.195156 +19478.145274 +42706.827956 +7468.282784 +9179.318864 +-19064.482427 +-11050.162633 +-4069.573551 +-20236.701924 +-4774.813473 +-10562.225646 +-40399.069661 +36098.720453 +\N +19723.395663 +-16216.888868 +-10301.702358 +-44641.045758 +-26388.493356 +11752.101249 +-4839.638274 +-33626.996578 +4560.885650 +\N +49823.360564 +8011.489063 +-15332.827096 +-17392.689999 +-4894.502114 +-43909.575089 +42227.864821 +-42796.692808 +46124.794239 +49378.032423 +-14683.174325 +20366.530805 +34097.297575 +32478.850606 +8170.419772 +-8223.727792 +21890.036795 +-35518.088464 +3255.037616 +-26883.612609 +38331.770845 +28900.054460 +13259.653404 +-41328.750919 +-30110.228425 +16669.586984 +-48892.083717 +-1572.836866 +-15162.140208 +30800.575707 +-23554.860695 +-5392.605837 +-4531.943637 +35743.463126 +-10121.817356 +14199.003887 +-30907.097310 +\N +15981.741979 +-12242.556625 +\N +20565.261632 +29723.813981 +2201.998770 +35425.610321 +\N +-33057.145580 +18323.757159 +\N +36334.147391 +7299.459985 +-24278.656055 +16489.392317 +-4957.447506 +1084.753522 +5137.974655 +-30360.079734 +-35963.294788 +-36720.662604 +22617.910976 +-20773.914396 +-48732.154490 +49075.305368 +-33554.497540 +-33566.020515 +12324.930896 +-28225.983250 +13358.032826 +-18160.350001 +\N +-34552.779135 +\N +41160.231871 +-2592.114244 +-16363.016361 +1515.679272 +-25992.747897 +6157.742793 +49813.482771 +-42797.604712 +21229.699753 +23316.666471 +-12701.805384 +-21669.538352 +40858.413275 +29064.950244 +36563.419917 +29932.275498 +21511.151442 +-22756.556642 +-32032.911378 +22570.534736 +-45668.180425 +-42143.193256 +27307.952604 +-41940.378301 +1165.639074 +-30360.167604 +16814.122706 +-38051.774208 +-17471.520727 +-48643.786273 +-39387.317043 +42320.112275 +207.400532 +-16455.292640 +25445.578748 +31528.860601 +\N +-33560.182938 +13079.843141 +-11665.444617 +-16201.473664 +-1374.085132 +7244.840012 +-13434.531243 +48046.297486 +45227.895675 +\N +-13172.942010 +-42981.365134 +33988.954818 +34644.785051 +49431.333178 +32323.511728 +28932.128604 +11985.751736 +11215.551459 +-35528.816462 +43658.061043 +-25850.170886 +23524.175293 +17178.292092 +46801.419322 +-26688.953990 +-2389.738454 +-2858.054709 +-35202.892304 +48787.430068 +17809.845352 +28326.733540 +42984.074351 +-26945.552452 +-16085.639906 +16843.088794 +47375.773963 +41011.705385 +14885.293303 +\N +22111.838158 +-37387.821631 +-36212.165787 +27804.290353 +23844.674031 +-39495.544038 +5529.709419 +35471.664130 +\N +44955.043353 +16079.612899 +42866.633689 +\N +\N +-16233.995495 +37244.619796 +-15405.819316 +5616.408845 +30540.014515 +22247.546153 +33114.272907 +-45238.189304 +\N +41761.467043 +-20499.635521 +22675.055718 +\N +12766.363268 +-15080.737353 +-15981.984775 +16029.268441 +\N +16697.867805 +-30822.994179 +-36990.879004 +-17886.208495 +25553.554239 +\N +-28515.186616 +38824.852132 +46412.142178 +25069.947063 +14387.938736 +-11086.348100 +-42786.775014 +\N +-8061.033561 +37733.424496 +8801.456941 +13686.325291 +-20484.612170 +28992.663361 +-8707.582186 +-28635.811563 +5881.871775 +16826.317444 +32660.964449 +26269.912848 +12482.768466 +-42628.871180 +27770.539968 +13275.355549 +-4267.695804 +\N +\N +38915.525185 +\N +49227.709975 +45488.034233 +26791.724598 +20869.828235 +48792.871180 +-46357.922208 +44961.768899 +20076.503078 +38215.656992 +\N +-11260.981700 +44876.038700 +38554.909960 +-568.573247 +12151.735305 +-18925.553360 +-16326.475361 +\N +645.930390 +\N +-16438.064150 +3638.865032 +39160.184697 +-20676.137540 +-17177.171338 +-33331.866694 +-30275.460044 +9681.845438 +\N +27081.356979 +10523.698228 +-44343.898024 +\N +-16863.860826 +26474.786679 +26905.474009 +-46422.688894 +-39975.798265 +29277.652166 +34617.731294 +7810.514820 +25256.726041 +31218.587272 +-22708.083211 +28732.503708 +-679.955515 +48438.095114 +-11875.156808 +-17232.257113 +-9389.997907 +35281.885641 +-34872.361545 +\N +38439.435367 +-5587.460778 +-24714.934907 +6119.993588 +-31999.541438 +-49884.042935 +41458.972912 +-18030.935371 +\N +-24749.192723 +44979.791387 +46251.140161 +\N +45017.657240 +1304.492518 +45341.311020 +14153.473295 +-9937.205473 +-13588.917751 +34439.616783 +-48495.188168 +45733.536079 +48187.489201 +43300.418227 +31616.128553 +36077.370954 +-1197.572961 +-13392.077509 +-3313.843279 +22281.588229 +26971.923130 +-47753.553883 +-35947.909153 +-33973.746600 +38374.616107 +-45586.414680 +-16247.553875 +44300.227004 +-19402.969940 +48321.487614 +-28888.746947 +28947.190139 +28660.995084 +-11618.051846 +-43953.376028 +-10910.886787 +-8197.079579 +45961.838260 +\N +22499.815688 +29963.217759 +4572.943204 +-663.480140 +-5134.120889 +11258.622846 +22652.566979 +-42431.771798 +-2914.722754 +-26206.211502 +-26095.177129 +-26219.617192 +22693.988482 +-22495.323686 +46860.070106 +-25156.352611 +48733.543651 +38955.635712 +-22823.721717 +37840.300746 +-34850.825549 +23549.032292 +\N +-29443.178689 +-24858.371902 +37761.087244 +\N +46819.624164 +\N +-33693.144090 +40653.983453 +-26031.282486 +-24553.259497 +19714.503628 +-34474.345196 +8479.883456 +-33258.695939 +33087.950890 +17223.332481 +41600.595923 +-24101.627559 +45225.386273 +7144.885816 +-25243.179209 +-34920.445683 +-31098.240605 +-42560.678764 +16588.400754 +-35012.138861 +-8465.407211 +24885.269056 +1185.531892 +-42427.891210 +30568.514010 +-42910.065638 +-25427.667506 +49703.152850 +15339.563585 +-36162.816587 +\N +25849.401427 +30508.323238 +39964.989009 +-29568.012561 +-22074.867353 +\N +48713.154625 +-1520.744968 +36336.974374 +41062.088679 +-2003.634512 +-9037.801465 +28679.307540 +9146.625390 +23064.029018 +-37993.003516 +-16414.231186 +-2807.518818 +12352.072057 +13036.899205 +-9238.011185 +-45646.203680 +-26760.931302 +36327.588086 +-40820.465465 +-11081.759474 +15407.617374 +41678.071204 +\N +\N +-43507.700410 +24709.613796 +30447.305730 +-11054.192745 +\N +23353.155969 +46508.126145 +6981.355956 +21083.087321 +23906.590032 +38666.058652 +-1769.736340 +47240.657405 +-1764.098532 +-5218.443393 +-33834.449008 +-2977.604676 +-432.298309 +24849.356606 +18835.457959 +32506.030883 +-19205.680149 +43736.106527 +-665.804581 +-7721.326434 +3269.641033 +-49370.767409 +16273.904297 +662.390678 +17499.127457 +30066.082524 +-9073.769189 +28401.596043 +-16385.018437 +18027.110150 +\N +9804.530004 +12884.736463 +46511.284540 +-8051.955215 +-44326.810536 +-16389.214185 +41559.840176 +40672.067921 +1770.764334 +-15898.218176 +204.035430 +8434.125203 +-38309.302967 +-15565.175780 +-13882.281661 +-24141.443695 +44535.343952 +31507.292987 +23152.546758 +-39375.797840 +-38180.703478 +-415.027351 +\N +29397.380994 +\N +47904.062270 +-46523.514994 +22100.205660 +8730.225525 +-31533.990419 +11804.385093 +-30083.302585 +-37654.674513 +-43752.615104 +\N +-1452.872507 +-21721.060142 +8709.210511 +38917.112904 +\N +18148.277545 +\N +-2368.107416 +-34462.417841 +40637.684702 +-42576.995163 +\N +31314.380645 +-2993.921634 +-18056.906931 +26346.102998 +-31676.115180 +34094.465563 +7338.040814 +-27818.175767 +46722.334715 +-31033.022181 +-10355.819231 +12291.897909 +-35065.719851 +21197.209494 +-33092.215417 +\N +34034.608716 +-33796.447601 +2756.714939 +-43451.564896 +-26799.277904 diff --git a/contrib/btree_gist/data/inet.data b/contrib/btree_gist/data/inet.data new file mode 100644 index 0000000..687fcba --- /dev/null +++ b/contrib/btree_gist/data/inet.data @@ -0,0 +1,675 @@ +205.48.101.94 +64.191.16.251 +104.18.168.108 +32.163.254.222 +95.221.129.147 +183.253.140.85 +70.165.215.123 +84.170.107.43 +79.144.216.22 +\N +165.90.225.162 +238.233.177.15 +88.24.114.39 +\N +155.255.145.81 +83.13.81.117 +31.236.39.111 +31.223.45.140 +204.136.128.221 +\N +160.69.78.40 +88.170.171.22 +27.205.158.253 +121.179.104.153 +225.15.14.165 +1.180.121.239 +83.5.70.6 +\N +237.24.51.229 +120.151.214.171 +62.124.72.116 +253.74.141.202 +237.188.81.187 +61.252.190.144 +57.206.2.191 +\N +240.82.109.101 +209.125.201.244 +93.213.169.237 +139.112.18.173 +82.154.56.140 +\N +227.137.163.196 +69.77.51.75 +30.194.154.142 +193.185.41.198 +92.173.29.28 +103.28.183.154 +220.205.180.198 +74.216.214.72 +213.87.102.109 +240.47.114.57 +123.231.125.27 +134.239.185.20 +\N +113.195.56.93 +24.40.244.54 +172.109.167.148 +231.44.133.66 +44.67.142.219 +239.181.165.233 +124.235.41.48 +190.73.207.202 +74.159.254.108 +153.37.38.182 +189.99.7.199 +37.164.159.15 +105.9.31.250 +\N +4.16.24.165 +195.21.199.159 +162.106.77.88 +239.95.217.230 +150.197.150.14 +79.223.250.16 +65.207.143.228 +135.165.49.229 +91.1.57.212 +194.161.198.219 +\N +1.163.185.97 +131.96.207.198 +\N +216.88.243.136 +126.254.48.253 +\N +56.199.135.75 +165.11.118.48 +247.7.198.248 +106.96.249.227 +96.14.187.22 +\N +209.33.227.131 +136.206.43.175 +213.39.115.236 +\N +124.100.183.145 +2.254.243.185 +80.111.117.99 +200.56.244.221 +232.45.235.183 +92.190.136.92 +\N +194.45.213.168 +189.80.217.147 +221.149.51.2 +203.143.183.21 +10.76.215.130 +231.240.22.160 +228.107.124.145 +122.159.54.211 +249.175.223.152 +206.78.173.162 +176.177.135.225 +112.159.227.116 +\N +140.34.214.128 +60.215.174.18 +120.23.162.179 +\N +60.88.199.80 +\N +190.199.234.228 +167.52.107.219 +163.230.62.220 +114.126.128.119 +28.212.246.115 +\N +35.24.185.39 +74.11.153.183 +128.18.38.32 +56.38.113.145 +118.200.90.79 +90.216.40.68 +\N +184.157.233.95 +247.216.240.149 +201.160.3.208 +121.229.71.154 +197.172.114.23 +147.134.141.252 +63.69.81.68 +172.15.14.208 +74.66.194.128 +102.73.67.147 +147.202.215.148 +40.253.212.235 +222.168.227.51 +193.171.47.212 +254.123.253.233 +13.238.20.95 +6.240.85.220 +63.50.72.59 +138.149.213.250 +\N +204.155.97.217 +25.64.68.108 +175.95.119.68 +136.242.20.94 +218.65.176.89 +194.204.44.77 +147.246.187.105 +62.207.123.111 +\N +128.90.38.245 +213.206.241.70 +143.101.67.30 +155.201.184.79 +205.190.209.57 +44.237.228.229 +222.109.77.139 +32.140.24.250 +36.125.139.29 +149.166.225.18 +172.242.93.116 +215.147.44.173 +230.46.69.48 +4.184.53.45 +241.179.116.11 +220.179.63.168 +193.4.38.153 +148.229.44.205 +213.60.22.146 +59.133.135.50 +198.49.80.122 +45.252.129.164 +161.123.162.124 +112.30.20.29 +58.133.184.67 +9.201.58.3 +146.112.143.36 +143.157.113.68 +147.14.52.62 +205.165.6.112 +29.89.113.154 +66.17.234.63 +52.41.89.181 +241.211.1.109 +177.36.163.207 +13.161.5.32 +125.114.169.247 +8.152.34.248 +20.31.119.242 +234.86.171.182 +59.226.121.144 +157.156.134.72 +143.41.246.125 +244.148.162.224 +161.221.171.40 +128.12.105.10 +\N +211.96.181.118 +132.98.248.99 +128.151.39.43 +3.192.152.232 +206.13.203.250 +220.239.170.173 +149.215.24.9 +18.182.145.36 +179.212.151.153 +68.95.24.250 +223.255.215.176 +207.71.249.41 +60.90.154.16 +173.116.151.18 +121.111.63.82 +111.221.237.4 +238.209.54.62 +183.236.220.28 +126.186.123.78 +123.43.92.163 +89.23.85.100 +89.225.196.191 +85.136.41.16 +155.170.87.73 +31.13.161.188 +137.30.169.129 +78.32.92.76 +129.121.108.107 +78.239.221.76 +36.242.173.3 +151.134.174.87 +79.94.194.177 +\N +9.108.86.70 +5.65.207.234 +84.59.213.76 +20.230.161.43 +247.180.220.136 +67.151.49.171 +47.147.80.252 +74.190.254.29 +\N +111.24.200.106 +90.3.213.132 +110.101.207.168 +143.77.140.198 +\N +236.62.95.154 +56.251.21.190 +231.154.66.237 +169.30.40.6 +94.91.100.20 +113.49.232.34 +215.47.246.82 +169.224.7.29 +\N +37.231.196.152 +47.63.95.236 +181.49.112.52 +243.161.244.167 +175.242.48.116 +169.213.125.67 +196.130.108.140 +239.250.45.132 +35.136.41.79 +111.112.42.173 +29.151.75.38 +38.137.224.147 +64.101.177.59 +55.13.87.142 +131.53.181.224 +199.167.12.86 +168.11.48.234 +34.123.154.188 +213.4.129.9 +\N +101.134.51.130 +193.64.107.205 +49.43.91.47 +104.238.95.198 +138.189.159.157 +120.251.32.52 +153.214.200.197 +243.134.30.100 +135.52.111.34 +\N +112.42.87.159 +40.69.66.232 +207.81.62.124 +193.28.195.69 +55.96.199.235 +167.101.253.115 +\N +246.147.199.115 +193.79.112.101 +241.244.120.200 +\N +167.116.157.80 +102.31.171.101 +16.44.204.182 +34.17.92.190 +84.72.45.155 +193.109.167.147 +80.181.11.243 +130.181.212.219 +9.144.1.64 +246.224.132.58 +62.195.56.251 +142.66.251.66 +194.106.77.154 +\N +90.221.121.253 +15.163.194.138 +230.46.78.158 +46.105.50.131 +119.50.45.238 +248.225.135.21 +\N +124.214.84.154 +21.180.109.92 +115.101.89.130 +95.207.181.191 +125.235.193.182 +181.218.105.217 +133.89.141.43 +106.183.231.192 +115.35.116.107 +60.97.101.50 +\N +169.250.64.192 +120.241.254.238 +137.194.100.209 +48.16.35.136 +182.211.204.114 +40.99.67.49 +89.125.172.183 +104.228.203.245 +81.84.155.227 +1.112.197.117 +59.117.175.134 +58.214.124.144 +33.129.223.81 +126.143.252.69 +195.211.137.176 +208.14.45.76 +74.96.74.146 +\N +229.64.51.77 +65.21.152.189 +\N +114.101.237.200 +175.166.116.210 +87.134.226.114 +213.95.222.202 +30.2.239.190 +\N +159.81.159.223 +228.187.227.90 +\N +67.251.123.95 +162.251.195.17 +96.240.115.112 +233.87.71.43 +161.114.80.142 +140.113.203.25 +22.40.68.5 +180.139.2.40 +\N +111.38.231.216 +228.234.207.123 +\N +250.176.79.79 +59.107.193.142 +161.218.191.212 +96.37.54.203 +46.192.107.103 +71.197.52.178 +111.105.63.26 +139.58.62.200 +72.105.233.160 +239.87.14.72 +171.229.121.185 +240.220.164.57 +149.13.111.63 +163.49.238.5 +7.149.70.239 +248.242.205.103 +17.229.150.23 +134.55.46.252 +98.238.40.42 +\N +31.36.115.199 +64.234.158.9 +\N +32.69.44.86 +186.204.118.229 +\N +20.35.78.52 +132.47.83.153 +226.69.230.4 +33.33.156.254 +152.70.244.236 +247.180.160.113 +211.221.104.110 +129.124.231.41 +54.190.14.163 +49.180.34.117 +124.77.160.15 +52.3.82.192 +89.149.87.98 +67.71.146.173 +182.61.251.67 +14.180.19.120 +\N +66.218.5.209 +188.58.131.244 +128.157.228.197 +\N +223.221.76.172 +101.115.226.156 +229.17.33.101 +151.3.214.189 +37.180.117.157 +242.106.122.78 +30.95.165.92 +132.52.246.117 +\N +173.52.188.128 +118.223.229.41 +132.231.133.56 +135.235.133.171 +78.200.1.131 +\N +115.146.120.61 +20.96.157.214 +152.229.92.114 +109.190.145.204 +243.82.98.207 +\N +184.107.160.144 +39.2.129.97 +48.192.2.91 +221.151.237.221 +4.246.15.78 +210.161.249.39 +255.75.10.97 +228.249.129.27 +30.115.201.232 +246.215.8.102 +\N +63.16.75.23 +94.123.36.30 +132.61.79.239 +\N +105.151.204.126 +\N +243.229.8.172 +26.195.227.35 +219.206.181.101 +165.12.89.14 +62.24.41.190 +119.79.245.119 +202.197.197.152 +109.202.220.212 +35.183.214.65 +53.7.220.159 +\N +55.184.109.15 +\N +15.112.129.183 +44.124.131.125 +35.89.161.4 +220.242.200.101 +123.60.59.238 +211.223.96.183 +74.61.70.183 +\N +209.150.35.249 +240.232.193.155 +194.231.101.62 +\N +2.104.84.243 +221.162.167.181 +119.166.8.33 +40.72.241.71 +\N +159.208.215.103 +\N +61.22.131.30 +\N +41.119.175.142 +117.85.224.118 +\N +148.167.101.4 +45.106.131.138 +\N +94.189.41.3 +108.55.214.7 +\N +35.171.168.47 +90.252.21.131 +27.220.123.246 +20.78.135.63 +166.27.102.106 +142.222.1.91 +11.88.28.225 +38.175.101.188 +163.37.35.66 +12.97.128.208 +106.97.208.4 +\N +152.139.250.11 +66.153.27.211 +102.132.218.38 +199.142.41.164 +18.231.165.111 +138.109.241.13 +118.10.77.46 +146.27.170.90 +168.77.102.159 +226.198.128.192 +66.92.232.222 +47.27.194.20 +164.182.228.118 +105.131.236.121 +234.46.48.100 +118.34.237.203 +175.160.139.46 +163.208.222.249 +9.166.171.40 +227.230.225.180 +244.160.119.181 +126.211.169.225 +72.112.141.239 +220.198.141.154 +197.173.63.107 +229.208.36.32 +132.26.237.169 +203.241.185.28 +191.42.250.138 +\N +132.180.213.190 +190.210.77.219 +49.168.123.181 +78.189.91.119 +\N +195.144.143.245 +85.75.58.30 +148.26.97.224 +65.174.36.247 +203.110.226.93 +6.176.17.101 +\N +99.2.116.45 +203.207.156.164 +6.205.71.174 +146.246.43.100 +235.93.237.116 +158.220.15.72 +94.113.101.124 +51.194.52.42 +162.80.213.241 +\N +23.1.97.65 +133.240.185.226 +7.27.121.41 +192.28.209.195 +179.208.158.65 +145.159.157.167 +173.41.74.199 +96.106.28.103 +244.63.22.62 +\N +96.163.254.226 +58.221.131.199 +31.86.179.136 +127.219.60.48 +87.134.167.151 +135.52.126.134 +\N +47.109.125.45 +41.170.113.98 +165.216.170.67 +252.176.159.106 +69.227.163.227 +225.251.187.1 +40.202.43.19 +4.104.139.43 +249.245.11.156 +93.180.123.182 +113.67.34.90 +142.211.245.230 +63.6.54.114 +77.65.223.214 +59.233.170.32 +131.172.204.238 +234.156.241.152 +\N +8.91.22.29 +117.141.48.215 +79.171.208.203 +146.229.67.176 +66.85.44.114 +241.194.191.85 +63.255.71.88 +60.73.67.41 +48.149.137.56 +60.33.119.210 +220.121.61.208 +147.151.1.144 +\N +184.155.244.115 +97.151.107.25 +249.167.212.72 +142.137.230.31 +24.86.8.16 +28.117.109.25 +149.148.184.221 +106.99.191.123 +\N +65.14.167.10 +164.183.36.228 +52.175.120.249 +42.0.8.134 +223.54.80.64 +62.203.105.165 +144.148.207.249 +236.35.62.35 +\N +21.116.77.153 +114.242.119.6 +136.30.45.211 +153.121.70.120 +\N +216.116.169.127 +230.106.70.22 +96.164.134.139 +193.7.187.21 +35.121.231.194 +105.62.79.80 +224.235.238.193 +238.75.226.70 +176.162.92.173 +214.188.162.23 +162.58.151.104 +6.119.102.63 +56.63.61.114 +6.171.110.128 +51.155.66.187 +\N +107.50.227.215 +219.149.74.222 +23.110.108.137 +244.190.60.52 +21.210.197.77 +249.88.71.119 +\N +62.251.140.171 +62.118.73.196 +58.77.130.172 +233.131.155.245 +59.164.211.253 +218.33.169.7 +\N diff --git a/contrib/btree_gist/data/int2.data b/contrib/btree_gist/data/int2.data new file mode 100644 index 0000000..b5d1157 --- /dev/null +++ b/contrib/btree_gist/data/int2.data @@ -0,0 +1,600 @@ +3093 +4550 +-3556 +-3363 +324 +-149 +-265 +-3432 +1122 +-2534 +-4263 +660 +-2263 +-468 +-3605 +-663 +-4713 +\N +1361 +\N +\N +2681 +-550 +\N +1935 +\N +2575 +-171 +-1557 +3897 +\N +3732 +3315 +237 +4012 +-254 +2564 +-4842 +620 +4255 +3282 +-4427 +802 +845 +\N +-62 +-4461 +2569 +4086 +-3787 +-2087 +2765 +2746 +\N +-1826 +4876 +1981 +-297 +-469 +168 +-3594 +2289 +\N +-3682 +2553 +2462 +3596 +-1129 +-4537 +\N +-3733 +2268 +2876 +-2178 +3610 +-969 +-3189 +142 +2196 +-1401 +\N +1827 +-2279 +2810 +-1459 +\N +798 +-1397 +2246 +266 +1489 +-4491 +566 +\N +\N +\N +-165 +\N +-36 +1695 +-2135 +1563 +3973 +-2041 +-1513 +-4820 +-702 +\N +3401 +\N +-3200 +3674 +-118 +-3972 +3888 +-1619 +3231 +-276 +-2622 +-2011 +-3959 +-1561 +1120 +2912 +-593 +-1062 +1368 +3198 +-1471 +4271 +2054 +2468 +-4511 +1104 +-287 +-4836 +1065 +\N +-3437 +-2120 +-2238 +1023 +-4333 +-412 +998 +1641 +3612 +3564 +4220 +\N +\N +4226 +-3195 +-3571 +-1505 +-3115 +494 +\N +-368 +-3459 +-2643 +\N +-620 +-210 +-4658 +2523 +-2482 +-3778 +1833 +509 +-4993 +\N +3208 +4760 +\N +-4898 +4324 +-3045 +-4555 +-3364 +1192 +4268 +-2170 +4229 +2952 +-3249 +-950 +2566 +\N +-2026 +4611 +\N +3042 +\N +1671 +-4874 +1518 +-1875 +1600 +-4570 +-295 +-2710 +-4290 +101 +2180 +-1385 +1438 +\N +-4992 +721 +1137 +1424 +4064 +1424 +842 +4073 +-4554 +1501 +-1886 +3087 +-3732 +1560 +2136 +\N +986 +-3083 +1062 +1557 +-465 +-2744 +-130 +3663 +1220 +-3390 +1491 +-652 +-3981 +-233 +3559 +4461 +-3630 +1080 +\N +-1289 +4821 +3670 +-965 +-969 +-784 +2877 +-772 +-1881 +-270 +-1645 +-1618 +-450 +-1353 +351 +-4492 +-1721 +-7 +-4545 +\N +2080 +987 +1645 +-4774 +-1215 +-2215 +-2675 +3747 +1664 +-4609 +1177 +1368 +-4010 +-3768 +2435 +-825 +-963 +-442 +\N +-991 +-3702 +2751 +1388 +808 +-2548 +3015 +-338 +811 +485 +-4178 +-1229 +\N +3246 +-3976 +-1296 +-3479 +-2069 +4391 +\N +-1462 +325 +4877 +2559 +-3954 +3456 +-476 +-2739 +-2737 +568 +-60 +-4371 +-4966 +-329 +4131 +\N +-1841 +-2219 +-2604 +776 +-4635 +1972 +-3333 +-4281 +-3046 +-1781 +2941 +-3399 +-938 +-4728 +-517 +\N +-3832 +-1096 +3094 +1949 +2494 +4686 +-3597 +-4346 +-437 +2490 +1625 +-4445 +752 +-3302 +2966 +-3870 +\N +-2594 +3754 +-186 +-3611 +3738 +473 +3706 +-4756 +1184 +-927 +-984 +2760 +\N +-456 +3202 +-1251 +894 +\N +-2776 +2545 +1566 +-4043 +-4577 +-1113 +-4865 +-4459 +188 +232 +4559 +2355 +1747 +4140 +1051 +3989 +-430 +-3136 +-2172 +-1734 +927 +-1278 +1051 +2750 +18 +-2888 +-273 +-2380 +-3709 +-2889 +-4733 +1064 +-3281 +-4176 +-427 +-2789 +-4779 +\N +-4472 +538 +3726 +3873 +-2263 +2414 +\N +3628 +-4210 +-1475 +2938 +859 +\N +-3648 +3644 +3967 +835 +1922 +-2946 +4903 +1090 +\N +4057 +-2531 +2858 +558 +4570 +-1384 +362 +-135 +2864 +\N +-1880 +1697 +-103 +980 +-2721 +2015 +490 +2561 +-1806 +-2533 +-672 +-108 +-2162 +613 +-2769 +618 +-4370 +3117 +-1692 +-1547 +-1034 +-4782 +502 +3117 +4913 +-4492 +188 +917 +465 +962 +-3792 +-1346 +-3899 +848 +-4530 +-3025 +1265 +3701 +2046 +3451 +\N +-2628 +1758 +\N +4732 +983 +\N +370 +-3513 +-147 +2705 +-1167 +-4962 +1453 +1196 +-1890 +648 +-3137 +-158 +-499 +4982 +-2287 +-1767 +3892 +-3490 +\N +-4331 +3110 +1613 +4379 +-2047 +3137 +713 +\N +-2956 +2247 +2580 +3198 +-2453 +4420 +3192 +-658 +-3912 +3018 +-234 +-3049 +\N +-2705 +2225 +-455 +4140 +145 +2198 +-4912 +-2327 +-2366 +-1114 +-172 +-748 +-2851 +-1596 +-4257 +-4451 +2070 +2161 +535 +1714 +\N +4808 +-924 +-1990 +3560 +-1490 +-3458 +310 +1562 +-4423 +-1375 +1169 +2452 +-2944 +-1091 +-2156 +3378 +-4723 +-4549 +4893 +-4295 +4103 +-1213 +4542 +4192 +228 +\N +566 +-2829 +750 +-2819 +\N +54 +-745 +-2611 +-464 +2098 +255 +-2791 +110 +-1020 +1313 +3705 +-3461 +511 +2079 +-3852 +1177 +2751 +1023 +-3970 +-264 +-148 +2085 diff --git a/contrib/btree_gist/data/int4.data b/contrib/btree_gist/data/int4.data new file mode 100644 index 0000000..66c4206 --- /dev/null +++ b/contrib/btree_gist/data/int4.data @@ -0,0 +1,600 @@ +-278383369 +-747067264 +-444347454 +943059602 +760126298 +-313957087 +69871373 +1047228793 +549563771 +-849172813 +742152707 +-102126707 +-588216468 +-587679276 +121951908 +-12908316 +-938566787 +-1066376866 +-70757527 +887181957 +-416180675 +-395333602 +-476539199 +-559145553 +166603938 +-995460982 +423400029 +-715704678 +-919392688 +-654070990 +-382421072 +631560114 +-729854703 +-201487528 +-1015231681 +-111081607 +-150879882 +-822966764 +-235383789 +664472573 +418592852 +535580213 +1006220943 +-772410787 +-933257976 +-93888809 +534823075 +348910859 +-954633892 +161536478 +-709184521 +636988950 +-831019781 +\N +-557156033 +806151247 +-39951046 +-775508567 +\N +101482645 +795803474 +-1021371457 +254190941 +-198991605 +-211220357 +592642976 +159564926 +-97980046 +687623361 +-268671335 +192044603 +133023521 +-596127139 +546530680 +336306348 +-868276189 +-982853141 +-239020404 +-1044842390 +-957480672 +40377556 +49864481 +\N +505742335 +375096111 +\N +225695129 +856735725 +-92417405 +-673413352 +-466398428 +-372271859 +199069838 +-274470034 +225807793 +590462307 +3775258 +-620113195 +-58682105 +-511020053 +-796515704 +-620432149 +-1016328347 +228460677 +-704579869 +-896860429 +\N +\N +-1026387226 +-974499141 +-960283687 +115614636 +800148518 +831654092 +\N +518360994 +\N +779114556 +-904139163 +-316769082 +630950752 +\N +-55878393 +-783306330 +\N +852002029 +179256342 +412777993 +-632735583 +1052807112 +234006613 +528787810 +871273145 +-543437833 +613656227 +119746596 +981397980 +-297248487 +77649335 +-28913402 +614934531 +929940199 +-403660500 +364477031 +-22124387 +210404268 +\N +432660770 +105294608 +\N +-387805780 +-543871814 +-144364887 +-23259185 +-464225973 +131691359 +-594587949 +132792222 +-938482467 +669399965 +-363432139 +-332135297 +-222020946 +-1026899728 +107886324 +669465840 +1055107642 +-964572059 +\N +196967371 +99878136 +206583116 +-814267157 +-288969105 +-837297170 +182146005 +-972850964 +-649642105 +271750475 +794876066 +439409907 +741102414 +-896013712 +-564452917 +377584215 +785128489 +1016266473 +211032352 +-860051372 +79557251 +-754415346 +-31656520 +580909957 +-250670377 +-1065498478 +312055768 +256848844 +-405941467 +139226727 +-673719257 +-33907454 +-107071600 +\N +-491151352 +-379374978 +835717683 +-749442365 +391779355 +-930175254 +667789784 +346287223 +940296232 +-439643120 +673648096 +153155023 +761570957 +-634729660 +482454328 +553985095 +686753002 +-526797052 +949281215 +685507933 +-141218391 +-840157851 +648180473 +-50333869 +-654708416 +1040352328 +-580798126 +477781101 +-97755360 +889044981 +31130520 +472121821 +-1054910894 +-499784982 +-508051907 +-239312888 +-36874490 +-160560442 +-612146051 +\N +-914254016 +-955919451 +444572750 +464011997 +114922279 +368088103 +\N +1032465403 +-198412817 +-427355634 +764561021 +-319968927 +-742495989 +66602125 +335474465 +\N +-295255877 +250999059 +526539904 +-632305975 +\N +-462933479 +725444821 +-1014220649 +-976950894 +1050779420 +-922337893 +881175599 +-260490744 +975381286 +900263262 +48922968 +-598347542 +121514864 +-607528559 +\N +-605421206 +-1033560416 +11538600 +-160000018 +-560613615 +-99553157 +450510072 +54811495 +-599428633 +23616163 +-218984524 +281874162 +795632049 +-743284993 +109773364 +446413166 +-827212018 +\N +590703606 +219585528 +-852527230 +-56743535 +-31888159 +447756894 +81597117 +-514906619 +829002820 +194782415 +-861939426 +789235257 +1002760541 +77986645 +124541179 +839847275 +688643973 +\N +-818330059 +\N +\N +571483597 +1043237102 +\N +-260795164 +\N +-80635223 +883946580 +-997239646 +417377536 +\N +905148727 +75086673 +240863213 +-974803948 +-514042316 +780396140 +-773002241 +-839043143 +-1050961764 +-944793472 +971511639 +862816002 +-87163815 +\N +601763342 +409313850 +-376132854 +-104608772 +793131268 +-402748367 +103010521 +589866409 +\N +-806207129 +-92467487 +382080273 +-537053065 +296991677 +450543728 +36073823 +-518334030 +\N +-823745191 +567487602 +82546145 +-388387055 +862364138 +1063492312 +\N +-758175718 +910291639 +-161138360 +-397892038 +-543779825 +-678530933 +-245281302 +1038476033 +992074486 +248548658 +\N +98497175 +-171252301 +18217558 +682347077 +\N +310612886 +-118028644 +337185821 +-210791469 +301448323 +-906803508 +-356807299 +\N +\N +\N +559848005 +\N +31316502 +-952852111 +-906201820 +86880549 +-1067074828 +-554439888 +-372251154 +767868870 +485181743 +\N +234322120 +\N +469476289 +120818420 +973859819 +553938979 +666244197 +-1034134335 +-643847604 +-928942436 +-40098720 +913202598 +-634013637 +-124514124 +88422182 +362344229 +-955696569 +-883518062 +-589118966 +-917271271 +-789577219 +-1055370400 +653530707 +751509060 +-923377500 +-896739670 +1049674425 +713830537 +-919850486 +\N +464008848 +-500611805 +1052904894 +1005514228 +-464230048 +940348010 +-521487154 +196319826 +-827331032 +606501605 +419601479 +\N +\N +-763299772 +-551662126 +-996151300 +656870503 +569347075 +-768904837 +\N +-364654847 +-352793070 +-560639559 +\N +69488952 +-236949153 +8643035 +722046549 +772759204 +934327163 +952426653 +-992250784 +-688516267 +\N +23371654 +-277401737 +\N +392817327 +-455495167 +208331771 +76220225 +-965469751 +-117604765 +134109425 +-286846823 +-976521495 +359070260 +-1033796401 +397275542 +928779613 +\N +-479010011 +-408187297 +\N +-544847539 +\N +-328541470 +862677577 +-742793122 +-221057238 +-743659309 +-165126079 +-241769542 +-634439156 +228542599 +70091032 +763329904 +-269836367 +-86158045 +\N +279028361 +-575426235 +-726811335 +260613141 +176220403 +-722725936 +800015615 +-223367075 +338624364 +195939828 +-751945238 +348787257 +-997923024 +-8605001 +-568010250 +\N +-962777966 +870581366 +-713036908 +-307366031 +1058650551 +-8016540 +604533525 +774656817 +-148155805 +194042034 +944121304 +502530876 +-728423603 +567787452 +1051834880 +-1050394394 +843329917 +-583580255 +\N +814196699 +1041013209 +-532683489 +644480699 +-1064568183 +-302358011 +66224442 +-779159623 +373241073 +652059193 +153158612 +1019561792 +-159367912 +764825007 +277019219 +539033342 +-99541768 +-748934480 +683758505 +\N +110932412 +875195202 +154556209 +109603003 +32090837 +-763742564 +-76548222 +-910116085 +675149363 +-813726843 +-366033349 +995685874 +-987030706 +-135458917 +985423987 +-293582113 +88167527 +962971281 +\N +345458787 +244011716 +530986493 +-985258624 +-972350494 +84247136 +854078794 +377796622 +-324275021 +-878489620 +864262985 +180124912 +\N +-793083147 +-352435244 +-462586860 +-74556106 +28209937 +222627005 +\N +-760794594 diff --git a/contrib/btree_gist/data/int8.data b/contrib/btree_gist/data/int8.data new file mode 100644 index 0000000..9deb47b --- /dev/null +++ b/contrib/btree_gist/data/int8.data @@ -0,0 +1,600 @@ +571162582773129 +-968633726566092 +-84469929177915858 +4162557330816307 +37260777124104530 +-4777143170215921 +-18226963197866476 +-8625828876661828 +7656239724464679 +-5489288588377948 +-63386438189169149 +75567289191112039 +-41526404145192890 +-4533895872892689 +-82739169202936497 +6911236575041352 +75842816214481185 +\N +7669153338841222 +-37026243121878430 +-3175877126637642 +-16007995163334251 +-3395795664631244 +63935989156878460 +-16954091159640632 +5318858710978884 +-3108641393657255 +55102218209821952 +-8798896163938228 +-2840321381342671 +73738755119374157 +59644096131825710 +-84322607121172895 +-60180910135826388 +-2124570924863354 +-10333657186851396 +58703296194197255 +56676327154787999 +8481545099866909 +464571291354841 +\N +-32049226128340060 +\N +62491046169211228 +-4178902379487935 +-58704035165707105 +-4370744691117233 +-1145699597209467 +71898480208016040 +40210785139855015 +30111868125808287 +3442459016537352 +\N +-9847254040823009 +28204892100790341 +58222430175280391 +-5250734726525414 +\N +7331215572768482 +\N +7855555216013852 +-8445953483741985 +-553872842685130 +3758966176486019 +\N +68254106110727666 +-779085030760061 +9530941396584628 +17210298132952098 +15654503142207692 +-12642726199954453 +95074133209723437 +-44100539106198634 +-42897443120872206 +-70803370174642981 +53824237192501978 +14091118778760 +-72030601214124822 +27500286125861367 +-4058285263735350 +\N +850104221271283 +101571367179586565 +-105758499180483916 +14231743102597792 +9115311735961929 +-5264208557722402 +1462317488951483 +88960681204192702 +79197578144317932 +32261563115032881 +-19665360148210462 +-94405000169758831 +\N +5681300149925625 +5558458639524735 +-81538564141087644 +5508723459108571 +-29815658164026313 +46416288118123076 +-2080732169659869 +\N +6778478169280557 +-51815253164990834 +-5552057233004262 +-3530123878334630 +\N +-79781393192459088 +81091470135265063 +-3174546872057439 +-43491832133972989 +-26029833130989740 +3551109553373570 +\N +-982183979826234 +13323171191699130 +-3271539392992822 +478227196042750 +-41112576193858203 +97184864103977346 +73232664160658748 +3461370054794093 +5763508331306600 +-54067138148025345 +-75460101103530266 +-315484375600487 +9769190516994377 +\N +-72400967138661448 +\N +-10234725547449166 +-6051348037059350 +-2952261266043490 +75387914189279439 +3625967156008709 +-3766224622641800 +5898363257062410 +7698143425285206 +66546389146435468 +31200605132406177 +-3455213658576548 +47528730130302036 +62432830201286045 +-88472988116517129 +6825920650153638 +-46045869146143591 +6326172435402615 +-5919362998522005 +36401689161832477 +80326684899441 +4144471433608822 +5800063247595057 +-44301689196562406 +-6466479342162519 +-89535305105978555 +37464982130305086 +60232609173699392 +98323565101041419 +40099224107628429 +3226497172413119 +9238219853212754 +-1319461392548924 +97305838213564393 +752930892266536 +28408158162749842 +-87755317206819285 +80611167141629044 +-94055745195646002 +-73914297162645226 +-8246391150836051 +48938555118563058 +\N +-21228069105374351 +-31494183206308739 +\N +\N +-559081218598528 +17582315157740574 +74577592104106586 +-66735635209305671 +68257070213090596 +-6488749444380913 +-36968819122130413 +-35640469185246031 +9784971155581421 +21965956184257469 +-33025198141891978 +49224647180407910 +5142127206085466 +-40935100123530887 +533636213233375 +105489717166223849 +-131230197744959 +41828998199086393 +1971243766433517 +-873934263916195 +-2268220620617840 +\N +-2212273711508266 +2523744596981136 +97944271015587 +1720454174447185 +-1051086313079088 +-91905196206426419 +-31531876151110971 +69747799124920022 +4700849531099668 +-57732117189691029 +2847488818621365 +357976652379232 +-32560447173517911 +-1158053397641905 +-21736437137866308 +-17430356141694709 +-29946543151537742 +4728756183450097 +-70989678146724148 +78026986123049651 +3541070096728143 +1103371642176407 +-78857021155945773 +-104651503212762593 +-72082479133841767 +2868615668375126 +-7420152739539637 +-556652372234871 +-55819000120597832 +-91907154152964612 +-2727691960839202 +62416504185893525 +4619484558504848 +484698539302511 +5864338017307905 +-65197962143482233 +\N +90881747107819569 +54643963175081891 +\N +-34792399104423355 +-28850436210552816 +5001330979085503 +72990723181773288 +69414211169505452 +\N +-55512818157891961 +10050528050060089 +-613762631776546 +38246351168205376 +-5786513272830532 +101738698195446145 +\N +-77765032167083438 +-84816033119249140 +105242892203914398 +92055393128607360 +-34862239187356390 +12061146172958360 +7111235810225910 +8968206663351549 +-106417733134789736 +-34321050141796771 +3585839741182305 +-38410339162250019 +-61235896190749913 +53837300138272042 +-9188389860977835 +81031910126275164 +-43990369169635449 +-61494936120005403 +70138886163788387 +-91544802167010959 +-9164807100625716 +835704521750764 +97684808164908969 +1047818917821302 +43113961189441677 +-24182774203744737 +-1221002133469832 +-35060838149098801 +\N +8409585462972514 +-7157963742358126 +26000275165530950 +-9522779489052570 +56854170165153244 +-85847371170247458 +16772952161612585 +-48765236169076760 +10402001581872476 +\N +18148261189922237 +-53074917120516766 +\N +6176962454225695 +9932356559664520 +\N +-2133998678192202 +-104142621205586199 +92986938175269298 +-257176878614913 +47849345165295943 +-7719754534416116 +-9789607872482825 +-41667560211143782 +62163616168923197 +-9438915483943230 +9870229482590359 +64345519117194501 +-11025440131551888 +-91121534101114861 +-5603896551067982 +\N +104654486191030769 +8126142532532604 +2739168944145437 +810913166922484 +-2275160635018706 +-5590175254646458 +-74033091125584591 +71055832144361004 +-51757850204494955 +-5420931332383096 +-91398360142997499 +-18179323160814887 +-91113201173019563 +-54605499214110886 +-7765905699369496 +65516124193198338 +-47405416136137551 +\N +-430277287965650 +19642228156903804 +-35249292101345079 +2799652787535702 +-57468661185387080 +-23797897140461786 +4713853950884486 +53063490172759270 +-97546793157524699 +14992347152649764 +83034727103573700 +-378837396167658 +-6394357106445826 +40448837177180348 +93922571105944376 +70215001351267 +1422473144953269 +-19485771168366142 +3871292384756271 +27669760207256401 +-9519109972178611 +87342599111176867 +438163125486326 +-3342596077562208 +95638921175035575 +-8455888025381745 +-5553812170504574 +1028731887465695 +1874801639655453 +-6460339926511384 +12935207104254160 +18702887190948042 +38973128194072985 +-74007477194642941 +48329901174621299 +-38776912163952004 +73217306123132502 +10033544840731274 +\N +-7106499073575381 +-72577317113294180 +-5755101056886868 +-2153332538359850 +3675308624690700 +-103461942101729940 +-64592601205133764 +31745072163056028 +-8827303101164453 +\N +9920716477549680 +19269113140876068 +10346764378482915 +-9547067291656372 +\N +68899277111163150 +-5154067635858711 +94977075194786589 +87693228128699438 +7485821479753669 +-8472668186271245 +2589559354466271 +107349961123032263 +-78000859126368058 +3033692340944986 +-56442118204131253 +\N +8313139926300583 +\N +20174427169387802 +-20817519112818564 +29328370152711004 +-10310696988128501 +6742185960379702 +9975388579236356 +\N +-75913155126775951 +-47356034144438153 +64337514105141385 +84133515165177048 +85904591142596001 +154102825333184 +82448968210511128 +\N +-4132665145813622 +457257666629329 +\N +-65756686131235045 +5770121211587146 +\N +-681329651615480 +18252938164428001 +\N +-964719458030678 +-4727044638245516 +14382487198474686 +104931686129854363 +\N +-524490443508808 +-5409828867122403 +-9181546297405233 +148961126577670 +-457861622113867 +\N +-8291535678315181 +31193366146847993 +-29045667151925792 +76199591212655385 +101708151208313969 +\N +7611981289809249 +-4063202412293642 +93382613193471632 +-66793190128641761 +2119337550577124 +50006559150465155 +-37785078129030470 +67070256141072548 +-57427591153091745 +\N +56930159168628907 +6262653086116434 +1812020175980923 +-60824628201994696 +-41445956104770511 +-98561174197889445 +65081378137952117 +-4709913937816332 +15168293135976771 +-79444556211593680 +54524573183207193 +\N +80599107103738466 +-15080292202625850 +3599922292681710 +10548113488081741 +-16095559175518178 +77523877187189428 +-1425168149826835 +3224427236896674 +-35199492127195051 +-6069164398850959 +9796493012969240 +1655940150099642 +5593028453315162 +54543795101679613 +-4901907019878396 +-16277768201853340 +42702008211664372 +100465864162056788 +\N +-7259772955295969 +-43344869168379475 +2387994273960108 +6813412213220101 +-35045975201264603 +-4169039115935033 +-3465320744627564 +\N +-8774505320366729 +-10234221080903233 +\N +-33431287210348996 +-18686684154709649 +11065021143131398 +98202891135320415 +-4804117047782001 +-8602172936734534 +1510532842674793 +\N +-48895594123983692 +1551674012705189 +-9340844216200742 +45730748190013165 +94523139162337073 +2609069738447319 +7695297236865360 +-18562157167827878 +-1388967693233129 +-3838287274649635 +36110661195956474 +-5738342872254390 +-5116252556595312 +7682319991347229 +55542449158580255 +-3007003760543423 +7296692443452118 +1155927925107625 +7543653043525059 +\N +-94909898165568234 +41218109154904764 +6633352313198796 +-15778782124332590 +103491985174098803 +-1784322577952292 +-9096880634185423 +5075356316566121 +5795491194207193 +70413333187654805 +60851035164462435 +-81411679171424293 +89150284196809557 +-8141710960632445 +21739482143854904 +104172284182307094 +-9010915383273451 +102243779193394851 +1446591350291789 +20672486141595277 +-10451707129953600 +3808314557084451 +4202888939347042 +61647148205322240 +\N +79376379132868914 +8760919795930088 +-45661711132605083 +-970917635875382 +\N +-105361387199605165 +-4047373221704350 +50014571178988278 +\N +-1945986026058284 +-70697134125038763 +968299419395944 +-54310692168796488 +-57071775143358867 +634196190032528 +87012477120875722 +1524418494420369 +4675805785402153 +-6649246646077956 +29400170100479605 +-88735135555188 +958687447945394 +36322738110509385 +-4530787153175354 +7246095930595264 +25762424121462081 +-101889593195744622 +-12299006125085795 +-8970808434914172 +-6316433271930092 +-4071744674545863 +12598555199787281 +64522791141639046 +91810857119110814 +-63801044209819006 +-8216052623004959 +\N +-43255707123485242 +4483587649977559 +-7266625765593156 +-3085636132347609 +-72544126194422740 +-42452203161494667 +\N +-65498988106251024 +-53102696163635269 +6547188826700461 +13150951201167246 +10110681961565834 +-73380538100200918 +98881899210477509 +21804516135251682 +-78292833188851738 +-31304191599521 +-21287065172320779 +3221074184065080 diff --git a/contrib/btree_gist/data/interval.data b/contrib/btree_gist/data/interval.data new file mode 100644 index 0000000..af418c2 --- /dev/null +++ b/contrib/btree_gist/data/interval.data @@ -0,0 +1,612 @@ +1748 days 11:26:21 +-2771 days -11:53:23 +-6230 days -20:26:04 +8945 days 14:56:37 +3581 days 23:33:20 +199 days 21:21:23 +\N +\N +-3568 days -06:07:25 +-3738 days -10:16:35 +1798 days 04:44:12 +10847 days 22:03:35 +-9527 days -15:38:39 +9648 days 10:24:38 +2256 days 12:07:24 +-4327 days -18:09:39 +-10857 days -13:31:07 +-5953 days -22:31:57 +6040 days 10:40:15 +10316 days 08:23:28 +-6639 days -19:43:47 +-8066 days -00:23:40 +2249 days 15:40:53 +10792 days 15:10:06 +-6302 days -16:08:38 +-12058 days -02:55:05 +-5738 days -10:39:26 +-10108 days -21:09:51 +-58 days -02:15:25 +-12240 days -03:38:13 +-59 days -11:53:16 +799 days 02:04:53 +7911 days 23:12:01 +242 days 03:57:29 +-390 days -13:23:08 +-5179 days -18:01:34 +-8577 days -17:10:05 +-11369 days -02:10:38 +-332 days -12:27:59 +1421 days 05:21:36 +-1310 days -17:18:48 +11773 days 16:56:50 +-4543 days -00:45:49 +-662 days -15:27:34 +-4847 days -13:30:15 +-7971 days -06:18:34 +1757 days 09:59:42 +3574 days 17:17:41 +2119 days 23:22:46 +-2935 days -00:26:37 +-3700 days -15:35:25 +-12058 days -21:45:31 +1503 days 09:38:15 +10519 days 23:34:24 +3575 days 18:19:24 +-10828 days -04:14:35 +-10607 days -12:28:31 +-938 days -02:09:57 +3453 days 17:25:05 +\N +-548 days -16:15:50 +-2594 days -09:39:39 +9024 days 05:44:35 +3370 days 21:44:34 +5502 days 15:10:21 +-11567 days -18:48:51 +-8329 days -12:27:53 +-6252 days -20:27:48 +9289 days 07:37:58 +8992 days 06:37:03 +-394 days -20:24:39 +-7805 days -00:20:59 +-12405 days -02:00:04 +11065 days 23:25:32 +-5991 days -05:00:15 +-2667 days -22:58:04 +7340 days 03:25:50 +-3432 days -02:02:37 +6979 days 12:44:26 +8861 days 12:43:57 +10377 days 06:21:51 +-1995 days -03:16:36 +-136 days -20:25:24 +4901 days 00:01:21 +-2662 days -17:36:30 +-10533 days -00:09:32 +90 days 15:09:55 +8068 days 00:10:48 +-10598 days -23:22:17 +10085 days 00:31:05 +-8281 days -13:41:52 +3990 days 05:29:52 +-8972 days -12:32:59 +-2321 days -22:15:46 +6416 days 13:43:59 +7215 days 15:02:19 +2076 days 01:43:17 +-3553 days -07:10:15 +8218 days 00:01:00 +-5766 days -19:25:21 +7727 days 10:36:16 +3414 days 01:24:30 +-8957 days -15:29:24 +7902 days 12:30:47 +-1183 days -04:35:24 +10302 days 09:31:47 +6163 days 06:46:15 +-10350 days -16:27:57 +1994 days 09:38:44 +7490 days 03:19:36 +4127 days 01:50:41 +\N +-4752 days -00:03:05 +9072 days 06:11:14 +5565 days 12:40:05 +11477 days 07:08:16 +155 days 08:17:54 +-10799 days -21:17:31 +6978 days 06:44:44 +-11813 days -04:32:46 +1322 days 23:25:33 +-4172 days -07:54:00 +-6942 days -21:56:44 +1335 days 21:19:11 +523 days 18:08:28 +220 days 19:05:42 +-1801 days -17:12:44 +9763 days 05:23:55 +-10965 days -20:16:30 +6490 days 09:05:30 +-11980 days -18:36:02 +2954 days 00:41:14 +-7538 days -14:38:35 +-2728 days -06:27:30 +-4375 days -16:56:38 +-5275 days -17:22:29 +-12473 days -22:15:51 +\N +2846 days 01:22:08 +8534 days 23:36:42 +10552 days 08:10:01 +1321 days 07:26:00 +-3600 days -00:48:35 +7951 days 17:51:17 +183 days 06:52:48 +-8472 days -18:01:29 +-936 days -12:03:46 +5467 days 14:23:59 +-8553 days -02:53:57 +-11491 days -03:21:12 +-10648 days -02:26:43 +-2966 days -06:58:23 +-12431 days -06:22:30 +-9162 days -11:37:47 +2698 days 22:29:45 +4416 days 08:44:27 +482 days 16:02:41 +-9629 days -22:39:29 +10917 days 12:49:36 +-3495 days -07:20:56 +5625 days 20:16:12 +1548 days 10:21:09 +-12923 days -05:28:48 +-2310 days -07:49:09 +7677 days 13:21:01 +8530 days 06:54:22 +-2696 days -09:55:01 +7343 days 01:40:45 +-4009 days -08:22:33 +7190 days 21:23:41 +1974 days 22:02:10 +6034 days 22:30:57 +-11697 days -04:47:36 +10012 days 08:11:09 +1204 days 14:58:21 +4667 days 23:00:42 +-10120 days -01:41:49 +8885 days 22:17:23 +-995 days -14:46:27 +565 days 02:23:32 +8068 days 19:50:34 +6715 days 00:51:20 +-2833 days -02:13:10 +-7675 days -19:12:28 +-6696 days -06:23:39 +1911 days 12:17:48 +-1128 days -04:26:05 +-7445 days -08:21:53 +-3892 days -14:50:27 +-5745 days -12:46:01 +-7389 days -21:27:09 +11436 days 05:06:06 +-2183 days -17:44:21 +-8301 days -19:05:16 +4941 days 10:04:16 +-1342 days -00:42:15 +-12044 days -01:16:13 +2758 days 20:28:33 +2832 days 18:05:22 +8076 days 00:20:56 +1457 days 19:01:58 +3509 days 06:02:22 +8288 days 14:43:44 +-7354 days -22:38:15 +-1453 days -23:14:42 +-7944 days -18:27:40 +-239 days -13:56:15 +-9699 days -18:33:50 +-10236 days -01:21:09 +-7188 days -09:39:59 +3234 days 15:52:22 +-10441 days -02:00:33 +-4574 days -17:32:16 +5013 days 04:00:31 +-4047 days -11:12:00 +\N +-10041 days -01:03:19 +-12435 days -15:40:06 +-11694 days -07:11:46 +-434 days -05:39:07 +-19 days -16:31:13 +-4947 days -03:22:20 +6049 days 18:30:28 +-5790 days -13:09:39 +480 days 23:23:21 +2155 days 05:03:12 +2438 days 18:45:31 +7113 days 01:18:52 +-3259 days -19:19:31 +-9646 days -06:50:26 +-7176 days -15:17:24 +10588 days 22:57:01 +7427 days 09:25:16 +-7762 days -14:43:54 +3761 days 15:53:03 +290 days 15:40:32 +5955 days 19:07:54 +-7101 days -15:58:50 +1283 days 15:54:51 +-1856 days -20:27:35 +3953 days 03:13:19 +\N +6286 days 00:33:36 +10668 days 05:28:51 +11000 days 14:01:35 +4973 days 08:38:59 +7503 days 08:55:14 +2837 days 06:51:40 +-2162 days -17:29:50 +9735 days 22:31:27 +-12643 days -09:03:02 +-3099 days -23:05:58 +3574 days 14:34:48 +-8487 days -16:33:27 +-3814 days -13:46:46 +-247 days -13:57:10 +109 days 02:01:52 +6894 days 03:39:53 +2791 days 23:24:16 +5763 days 15:52:42 +4160 days 22:20:52 +-3047 days -15:41:28 +10129 days 05:48:14 +655 days 21:22:30 +-1249 days -13:46:55 +-670 days -09:57:10 +8853 days 20:36:22 +31 days 23:14:00 +9370 days 13:03:26 +3914 days 00:30:54 +5921 days 22:43:34 +-3753 days -06:14:50 +9099 days 02:17:12 +2865 days 11:17:43 +2057 days 15:01:53 +-4108 days -10:23:00 +-5066 days -21:37:35 +2863 days 22:15:47 +-5654 days -14:37:25 +-11724 days -08:14:41 +-9317 days -17:40:37 +-12683 days -19:56:10 +-10364 days -01:28:57 +-12270 days -05:47:08 +-12181 days -06:26:48 +8378 days 09:56:31 +-9114 days -01:00:41 +-1174 days -22:58:50 +-9308 days -12:04:06 +1535 days 01:19:45 +-7855 days -05:25:15 +4205 days 00:35:17 +10507 days 04:27:33 +\N +-566 days -01:36:09 +-11306 days -14:17:28 +-10463 days -09:44:02 +-2679 days -12:29:05 +7233 days 00:29:37 +-2959 days -14:45:29 +7409 days 12:12:27 +-2951 days -00:37:54 +6076 days 00:27:14 +1989 days 12:23:54 +-6286 days -00:15:17 +-5485 days -14:17:50 +-8739 days -17:42:24 +3875 days 11:24:17 +-3004 days -13:30:19 +10383 days 10:08:29 +-8261 days -01:24:41 +-4398 days -10:43:25 +8738 days 00:40:22 +6148 days 23:56:32 +-5789 days -14:22:50 +4747 days 18:58:16 +11555 days 21:52:56 +7034 days 06:35:38 +-12510 days -12:02:30 +-7087 days -08:28:34 +-7587 days -23:09:54 +4831 days 16:01:13 +-7746 days -16:43:47 +1962 days 11:08:54 +-7050 days -07:09:35 +-2595 days -08:02:15 +3135 days 16:20:43 +4114 days 06:42:47 +6542 days 05:09:18 +-11449 days -20:54:48 +9299 days 12:41:02 +4299 days 05:30:41 +-196 days -14:43:53 +9134 days 16:01:15 +10910 days 00:53:35 +-10974 days -17:26:16 +2952 days 07:37:10 +-8030 days -20:45:05 +-4037 days -05:51:34 +7553 days 01:05:58 +-2253 days -15:17:36 +-3808 days -13:47:12 +-5893 days -02:28:14 +8697 days 09:10:41 +-12560 days -21:45:19 +\N +-6808 days -23:17:31 +-9275 days -06:24:17 +-4576 days -04:40:00 +-926 days -01:54:23 +-516 days -05:17:15 +4180 days 07:04:20 +-9826 days -23:33:11 +-77 days -03:56:25 +5599 days 05:02:56 +1247 days 11:33:16 +-11522 days -22:07:08 +1513 days 19:37:30 +-4664 days -17:59:08 +1202 days 14:16:15 +-5539 days -05:18:35 +-12706 days -23:17:47 +1735 days 00:57:48 +3471 days 20:40:18 +1365 days 00:44:23 +-8385 days -09:01:45 +7335 days 06:33:44 +-9736 days -06:09:59 +-8423 days -16:05:19 +-5411 days -17:11:17 +4304 days 01:12:07 +-4230 days -03:34:05 +-6570 days -22:06:27 +3576 days 05:13:19 +-2792 days -04:07:12 +-11528 days -13:42:31 +6526 days 19:45:07 +488 days 12:28:03 +2206 days 11:11:23 +10428 days 23:47:56 +-11168 days -16:23:59 +-689 days -15:58:43 +-5443 days -06:59:01 +-8505 days -05:59:07 +-6971 days -16:02:43 +5759 days 02:47:33 +-8460 days -12:54:34 +-6811 days -04:41:10 +161 days 04:05:43 +-3793 days -19:54:41 +5175 days 16:56:13 +9629 days 06:41:59 +-1957 days -20:57:17 +1386 days 02:52:34 +-11433 days -12:15:19 +6995 days 08:16:54 +-5440 days -13:50:07 +\N +-12569 days -02:07:24 +-745 days -23:01:35 +-12126 days -09:59:26 +-6827 days -06:16:45 +5415 days 05:31:17 +-8860 days -05:00:30 +4263 days 22:01:16 +5529 days 19:33:03 +-9951 days -04:31:38 +4518 days 23:16:10 +-7559 days -02:17:48 +-3262 days -00:19:03 +3369 days 12:43:16 +7394 days 01:50:49 +-8384 days -05:35:48 +10399 days 22:57:43 +-3315 days -07:19:47 +3558 days 10:47:06 +-11365 days -08:52:35 +7162 days 05:55:08 +-15 days -11:28:55 +-1488 days -21:17:32 +1888 days 11:33:40 +6764 days 16:00:41 +3693 days 20:33:29 +3903 days 20:46:46 +4438 days 19:02:47 +10668 days 19:53:49 +9658 days 03:06:51 +9572 days 18:13:11 +11185 days 19:57:35 +11347 days 15:46:14 +2565 days 21:15:51 +-1429 days -16:46:30 +-7691 days -15:31:38 +-199 days -22:25:06 +-2118 days -16:03:13 +3371 days 12:32:24 +-12416 days -21:18:04 +11799 days 18:51:26 +-5976 days -19:33:37 +5980 days 13:44:23 +-1778 days -17:18:48 +-4636 days -17:45:06 +-8502 days -15:11:20 +-3732 days -14:34:28 +-7282 days -18:28:40 +5062 days 13:33:02 +6399 days 13:41:08 +2291 days 09:09:56 +9458 days 16:06:07 +7678 days 05:05:33 +-12054 days -13:31:00 +-3362 days -07:41:50 +-5693 days -21:32:36 +6597 days 19:10:20 +5161 days 09:56:55 +-9860 days -17:18:35 +-2293 days -23:12:04 +10459 days 13:16:26 +2265 days 13:04:27 +10313 days 14:45:01 +10054 days 22:24:22 +2984 days 07:57:12 +-5791 days -03:00:07 +6534 days 08:35:43 +-11438 days -14:25:10 +-6859 days -16:50:55 +-8909 days -10:22:34 +-3517 days -21:18:12 +7480 days 00:21:27 +-795 days -15:06:11 +-9404 days -23:24:01 +7663 days 01:41:12 +-713 days -01:01:42 +1650 days 12:24:05 +-7495 days -05:04:58 +4000 days 21:11:36 +1138 days 18:33:07 +3944 days 15:56:41 +3289 days 17:22:03 +-8837 days -21:25:58 +-4677 days -15:32:13 +-10750 days -23:04:22 +10140 days 05:58:50 +6143 days 21:16:02 +3566 days 23:49:41 +5887 days 06:12:51 +5423 days 20:58:45 +5379 days 11:15:53 +2123 days 03:34:50 +-9389 days -22:55:12 +1357 days 02:09:47 +10142 days 04:25:36 +-6926 days -18:43:31 +-6424 days -21:14:28 +2982 days 10:44:03 +4922 days 11:17:28 +-2045 days -18:22:51 +-8943 days -13:02:39 +6900 days 17:08:21 +2510 days 06:39:59 +-1835 days -22:15:12 +\N +9024 days 00:03:49 +-2045 days -06:37:43 +6892 days 06:31:32 +-9844 days -06:17:20 +2870 days 23:46:12 +-5579 days -06:20:34 +-5641 days -22:13:10 +10487 days 10:27:35 +-7233 days -17:17:43 +-11226 days -05:05:14 +-5268 days -18:53:33 +-5999 days -09:32:42 +11656 days 06:29:49 +-8175 days -17:55:50 +10402 days 10:08:40 +-6480 days -11:33:32 +1328 days 08:48:12 +-2460 days -20:50:25 +-4343 days -20:26:12 +-12476 days -16:52:49 +-8221 days -00:19:12 +10934 days 04:29:47 +1567 days 06:22:11 +2907 days 10:19:15 +9512 days 13:17:14 +\N +10031 days 05:58:55 +7973 days 06:57:28 +9828 days 05:58:27 +-6372 days -11:15:50 +10012 days 15:27:44 +-9097 days -03:49:51 +-7206 days -00:00:34 +1026 days 00:49:11 +-1597 days -12:20:05 +-8648 days -00:44:16 +-9790 days -02:52:49 +-981 days -04:10:39 +-7541 days -05:47:56 +-7105 days -15:37:54 +-1748 days -11:26:21 +-4519 days -23:19:44 +-7979 days -07:52:25 +7197 days 03:30:16 +1833 days 12:06:59 +-1548 days -14:04:58 +-5316 days -17:33:46 +-5486 days -21:42:56 +49 days 17:17:51 +9099 days 10:37:14 +-11276 days -03:05:00 +7899 days 22:58:17 +508 days 00:41:03 +-6076 days -05:36:00 +-12606 days -00:57:28 +-7702 days -09:58:18 +4291 days 23:13:54 +8567 days 20:57:07 +-8388 days -07:10:08 +-9814 days -11:50:01 +501 days 04:14:32 +9044 days 03:43:45 +-8051 days -03:34:59 +-13806 days -14:21:26 +-7486 days -22:05:47 +-11857 days -08:36:12 +-1806 days -13:41:46 +-13988 days -15:04:34 +-1807 days -23:19:37 +-949 days -09:21:28 +6163 days 11:45:40 +-1506 days -07:28:52 +-2139 days -00:49:29 +-6928 days -05:27:55 +-10326 days -04:36:26 +-13117 days -13:36:59 +-2080 days -23:54:20 +-327 days -06:04:45 +-3059 days -04:45:09 +10025 days 05:30:29 +-6291 days -12:12:10 +-2411 days -02:53:55 +-6596 days -00:56:36 +-9719 days -17:44:55 +8 days 22:33:21 +1826 days 05:51:20 +371 days 11:56:25 +-4683 days -11:52:58 +-5449 days -03:01:46 +-13807 days -09:11:52 +-245 days -01:48:06 +8771 days 12:08:03 +1827 days 06:53:03 +-12576 days -15:40:56 +-12355 days -23:54:52 +-2686 days -13:36:18 +1705 days 05:58:44 +-2297 days -03:42:11 +-4342 days -21:06:00 +7275 days 18:18:14 +1622 days 10:18:13 +3754 days 03:44:00 +-13316 days -06:15:12 +-10077 days -23:54:14 +-8001 days -07:54:09 +7540 days 20:11:37 +7243 days 19:10:42 +-2143 days -07:51:00 +-9553 days -11:47:20 +-14153 days -13:26:25 diff --git a/contrib/btree_gist/data/macaddr.data b/contrib/btree_gist/data/macaddr.data new file mode 100644 index 0000000..12ef530 --- /dev/null +++ b/contrib/btree_gist/data/macaddr.data @@ -0,0 +1,644 @@ +4a:31:57:23:9b:54 +e2:cc:11:0d:3a:a5 +a9:2b:32:79:3e:60 +53:1c:b9:1d:db:c7 +\N +70:8a:83:2b:c0:23 +4c:55:af:1e:79:f9 +b9:4c:7c:39:c1:ee +c5:83:ab:17:63:50 +b4:cf:fc:c4:fe:db +12:33:a4:22:4e:a4 +99:db:22:10:3f:ae +f4:31:5b:3a:26:c4 +\N +db:a5:1a:67:bf:b5 +9c:c6:3f:59:ec:96 +8f:52:b2:83:41:b4 +49:ac:2a:44:a4:28 +0c:51:53:4e:10:79 +e5:54:31:9d:51:d9 +d0:8d:79:bd:4f:a1 +ee:ba:f1:4f:a1:bc +76:25:97:80:8b:a7 +3a:dd:50:3b:82:d0 +34:8d:ca:fd:24:fc +2f:f9:aa:93:0e:70 +93:29:d0:c2:7a:cb +3a:a8:a7:c9:9c:5b +8f:6c:0b:a1:1a:22 +ce:4a:b7:a6:59:9e +\N +\N +e5:bd:83:62:cb:59 +ba:d9:ed:2f:68:58 +48:18:7a:6c:cc:2f +76:03:b0:d3:ae:9d +ef:3c:db:66:d9:82 +2d:73:91:dd:fb:69 +33:35:c3:7d:50:49 +50:a3:e9:24:18:32 +66:eb:ab:3a:14:2e +a9:13:53:36:ee:95 +1f:4f:b4:57:34:0a +60:26:2c:17:5c:d8 +01:43:b5:79:eb:0f +c0:94:5d:b5:41:2c +fb:e6:51:d6:49:9c +87:7a:23:90:e9:df +78:52:28:a5:f9:1f +38:b2:03:d7:5d:b3 +bf:b5:5e:99:80:9f +7c:8f:73:5c:07:95 +ba:b8:6b:d2:ef:ab +9f:25:81:eb:33:0a +82:cb:7c:44:6a:5f +ca:46:2b:3c:cf:7f +17:64:2a:89:cf:59 +\N +35:59:4c:9d:5a:0d +c9:5e:a4:dd:bb:ae +d0:90:56:ef:30:05 +bd:2d:22:41:42:5e +be:49:c2:de:66:22 +21:cb:55:17:01:c8 +22:00:5c:e5:9b:0d +23:c8:5f:22:33:ca +01:02:37:05:4f:36 +91:ba:08:fd:9e:ed +bf:ad:23:1f:3e:4d +c4:a6:c5:bd:89:dc +b9:13:9f:85:d9:fa +7d:b2:c9:07:4f:bc +\N +7a:84:d0:53:46:30 +f7:32:0c:87:f0:2f +77:15:22:cd:68:a0 +17:f9:26:35:6e:73 +d7:21:4d:fe:43:22 +63:13:3a:af:94:e9 +f3:11:3c:68:ef:5e +76:5a:06:33:31:fe +63:d9:b8:ef:ec:36 +3b:f3:4d:c4:22:e6 +d0:a2:cb:f9:f1:0b +95:0e:76:bc:99:ee +ae:e7:64:d9:ce:5b +ff:5a:6f:a2:26:9a +75:96:d4:72:db:49 +a8:ac:2a:2a:23:67 +db:4e:14:4d:b1:7c +45:fd:c8:52:05:cf +91:7b:e7:6e:23:07 +71:50:0c:46:78:3d +a9:90:9b:c0:b4:fc +47:0e:9a:82:af:48 +e8:1c:cf:c0:16:d1 +e1:6a:42:25:89:c3 +\N +55:8e:63:3b:44:c8 +93:8a:78:62:38:70 +29:81:d2:3d:12:80 +3e:d1:1e:94:2f:5d +fb:8c:c4:ee:84:7c +\N +cc:ad:28:56:b2:4a +52:f6:13:94:b7:03 +a2:8d:f8:f9:f8:c0 +57:68:00:9c:1b:f8 +a6:e2:31:88:8a:b4 +41:f7:0a:bd:47:08 +bf:5c:7d:64:08:73 +33:cc:60:43:05:e1 +cd:a5:a8:b0:99:14 +ef:fd:75:f1:3e:99 +b8:b0:b8:85:80:53 +7b:1c:fc:5c:b2:c8 +92:38:0c:df:81:57 +1e:ab:d4:18:c5:3a +b0:a1:c6:88:a3:29 +c7:37:ec:30:2b:7c +5e:5b:32:94:60:f7 +9d:ab:93:1f:de:1d +ff:32:af:ef:10:2e +f8:54:03:77:0d:e0 +49:e4:f8:f7:63:41 +18:f7:95:42:ea:32 +f8:a2:40:af:9e:af +1d:e2:71:c3:be:6e +\N +6a:38:d7:a5:b7:cd +df:51:52:74:c6:d4 +f2:05:5e:d2:1e:f3 +85:a7:b9:dd:80:72 +ae:ad:f5:1f:d1:7e +cf:71:9a:9c:b4:4d +\N +ac:8d:0f:5b:63:21 +c4:f0:3e:23:9e:7d +45:91:19:00:06:fa +c6:b6:30:24:e2:c5 +48:e1:e1:4a:8f:99 +cd:74:2c:39:14:e3 +9b:bb:32:10:ec:14 +a5:3c:a6:c9:64:14 +bc:ea:9c:03:76:75 +d5:29:75:05:8a:5d +\N +37:92:8f:cb:f1:e5 +e5:eb:1b:0e:02:58 +9f:9c:a2:22:a4:25 +26:f4:f4:e6:b8:cb +dd:79:87:70:0b:e7 +80:87:95:20:cd:ce +0d:28:2a:d1:0f:e2 +05:b8:34:36:55:b0 +89:03:74:cd:43:a9 +74:10:93:21:1e:04 +27:bb:a9:3a:7b:f0 +73:3c:06:b1:51:ad +47:0e:59:c0:5d:38 +13:13:e1:1c:aa:25 +4a:31:57:23:9b:54 +e2:cc:11:0d:3a:a5 +a9:2b:32:79:3e:60 +53:1c:b9:1d:db:c7 +\N +70:8a:83:2b:c0:23 +4c:55:af:1e:79:f9 +b9:4c:7c:39:c1:ee +c5:83:ab:17:63:50 +b4:cf:fc:c4:fe:db +12:33:a4:22:4e:a4 +99:db:22:10:3f:ae +f4:31:5b:3a:26:c4 +\N +db:a5:1a:67:bf:b5 +9c:c6:3f:59:ec:96 +8f:52:b2:83:41:b4 +49:ac:2a:44:a4:28 +0c:51:53:4e:10:79 +e5:54:31:9d:51:d9 +d0:8d:79:bd:4f:a1 +ee:ba:f1:4f:a1:bc +76:25:97:80:8b:a7 +3a:dd:50:3b:82:d0 +34:8d:ca:fd:24:fc +2f:f9:aa:93:0e:70 +93:29:d0:c2:7a:cb +3a:a8:a7:c9:9c:5b +8f:6c:0b:a1:1a:22 +ce:4a:b7:a6:59:9e +\N +\N +e5:bd:83:62:cb:59 +ba:d9:ed:2f:68:58 +48:18:7a:6c:cc:2f +76:03:b0:d3:ae:9d +ef:3c:db:66:d9:82 +2d:73:91:dd:fb:69 +33:35:c3:7d:50:49 +50:a3:e9:24:18:32 +66:eb:ab:3a:14:2e +a9:13:53:36:ee:95 +1f:4f:b4:57:34:0a +60:26:2c:17:5c:d8 +01:43:b5:79:eb:0f +c0:94:5d:b5:41:2c +fb:e6:51:d6:49:9c +87:7a:23:90:e9:df +78:52:28:a5:f9:1f +38:b2:03:d7:5d:b3 +bf:b5:5e:99:80:9f +7c:8f:73:5c:07:95 +ba:b8:6b:d2:ef:ab +9f:25:81:eb:33:0a +82:cb:7c:44:6a:5f +ca:46:2b:3c:cf:7f +17:64:2a:89:cf:59 +\N +35:59:4c:9d:5a:0d +c9:5e:a4:dd:bb:ae +d0:90:56:ef:30:05 +bd:2d:22:41:42:5e +be:49:c2:de:66:22 +21:cb:55:17:01:c8 +22:00:5c:e5:9b:0d +23:c8:5f:22:33:ca +01:02:37:05:4f:36 +91:ba:08:fd:9e:ed +bf:ad:23:1f:3e:4d +c4:a6:c5:bd:89:dc +b9:13:9f:85:d9:fa +7d:b2:c9:07:4f:bc +\N +7a:84:d0:53:46:30 +f7:32:0c:87:f0:2f +77:15:22:cd:68:a0 +17:f9:26:35:6e:73 +d7:21:4d:fe:43:22 +63:13:3a:af:94:e9 +f3:11:3c:68:ef:5e +76:5a:06:33:31:fe +63:d9:b8:ef:ec:36 +3b:f3:4d:c4:22:e6 +d0:a2:cb:f9:f1:0b +95:0e:76:bc:99:ee +ae:e7:64:d9:ce:5b +ff:5a:6f:a2:26:9a +75:96:d4:72:db:49 +a8:ac:2a:2a:23:67 +db:4e:14:4d:b1:7c +45:fd:c8:52:05:cf +91:7b:e7:6e:23:07 +71:50:0c:46:78:3d +a9:90:9b:c0:b4:fc +47:0e:9a:82:af:48 +e8:1c:cf:c0:16:d1 +e1:6a:42:25:89:c3 +\N +55:8e:63:3b:44:c8 +93:8a:78:62:38:70 +29:81:d2:3d:12:80 +3e:d1:1e:94:2f:5d +fb:8c:c4:ee:84:7c +\N +cc:ad:28:56:b2:4a +52:f6:13:94:b7:03 +a2:8d:f8:f9:f8:c0 +57:68:00:9c:1b:f8 +a6:e2:31:88:8a:b4 +41:f7:0a:bd:47:08 +bf:5c:7d:64:08:73 +33:cc:60:43:05:e1 +cd:a5:a8:b0:99:14 +ef:fd:75:f1:3e:99 +b8:b0:b8:85:80:53 +7b:1c:fc:5c:b2:c8 +92:38:0c:df:81:57 +1e:ab:d4:18:c5:3a +b0:a1:c6:88:a3:29 +c7:37:ec:30:2b:7c +5e:5b:32:94:60:f7 +9d:ab:93:1f:de:1d +ff:32:af:ef:10:2e +f8:54:03:77:0d:e0 +49:e4:f8:f7:63:41 +18:f7:95:42:ea:32 +f8:a2:40:af:9e:af +1d:e2:71:c3:be:6e +\N +6a:38:d7:a5:b7:cd +df:51:52:74:c6:d4 +f2:05:5e:d2:1e:f3 +85:a7:b9:dd:80:72 +ae:ad:f5:1f:d1:7e +cf:71:9a:9c:b4:4d +\N +ac:8d:0f:5b:63:21 +c4:f0:3e:23:9e:7d +45:91:19:00:06:fa +c6:b6:30:24:e2:c5 +48:e1:e1:4a:8f:99 +cd:74:2c:39:14:e3 +9b:bb:32:10:ec:14 +a5:3c:a6:c9:64:14 +bc:ea:9c:03:76:75 +d5:29:75:05:8a:5d +\N +37:92:8f:cb:f1:e5 +e5:eb:1b:0e:02:58 +9f:9c:a2:22:a4:25 +26:f4:f4:e6:b8:cb +dd:79:87:70:0b:e7 +80:87:95:20:cd:ce +0d:28:2a:d1:0f:e2 +05:b8:34:36:55:b0 +89:03:74:cd:43:a9 +74:10:93:21:1e:04 +27:bb:a9:3a:7b:f0 +73:3c:06:b1:51:ad +47:0e:59:c0:5d:38 +13:13:e1:1c:aa:25 +4a:31:57:23:9b:54 +e2:cc:11:0d:3a:a5 +a9:2b:32:79:3e:60 +53:1c:b9:1d:db:c7 +\N +70:8a:83:2b:c0:23 +4c:55:af:1e:79:f9 +b9:4c:7c:39:c1:ee +c5:83:ab:17:63:50 +b4:cf:fc:c4:fe:db +12:33:a4:22:4e:a4 +99:db:22:10:3f:ae +f4:31:5b:3a:26:c4 +\N +db:a5:1a:67:bf:b5 +9c:c6:3f:59:ec:96 +8f:52:b2:83:41:b4 +49:ac:2a:44:a4:28 +0c:51:53:4e:10:79 +e5:54:31:9d:51:d9 +d0:8d:79:bd:4f:a1 +ee:ba:f1:4f:a1:bc +76:25:97:80:8b:a7 +3a:dd:50:3b:82:d0 +34:8d:ca:fd:24:fc +2f:f9:aa:93:0e:70 +93:29:d0:c2:7a:cb +3a:a8:a7:c9:9c:5b +8f:6c:0b:a1:1a:22 +ce:4a:b7:a6:59:9e +\N +\N +e5:bd:83:62:cb:59 +ba:d9:ed:2f:68:58 +48:18:7a:6c:cc:2f +76:03:b0:d3:ae:9d +ef:3c:db:66:d9:82 +2d:73:91:dd:fb:69 +33:35:c3:7d:50:49 +50:a3:e9:24:18:32 +66:eb:ab:3a:14:2e +a9:13:53:36:ee:95 +1f:4f:b4:57:34:0a +60:26:2c:17:5c:d8 +01:43:b5:79:eb:0f +c0:94:5d:b5:41:2c +fb:e6:51:d6:49:9c +87:7a:23:90:e9:df +78:52:28:a5:f9:1f +38:b2:03:d7:5d:b3 +bf:b5:5e:99:80:9f +7c:8f:73:5c:07:95 +ba:b8:6b:d2:ef:ab +9f:25:81:eb:33:0a +82:cb:7c:44:6a:5f +ca:46:2b:3c:cf:7f +17:64:2a:89:cf:59 +\N +35:59:4c:9d:5a:0d +c9:5e:a4:dd:bb:ae +d0:90:56:ef:30:05 +bd:2d:22:41:42:5e +be:49:c2:de:66:22 +21:cb:55:17:01:c8 +22:00:5c:e5:9b:0d +23:c8:5f:22:33:ca +01:02:37:05:4f:36 +91:ba:08:fd:9e:ed +bf:ad:23:1f:3e:4d +c4:a6:c5:bd:89:dc +b9:13:9f:85:d9:fa +7d:b2:c9:07:4f:bc +\N +7a:84:d0:53:46:30 +f7:32:0c:87:f0:2f +77:15:22:cd:68:a0 +17:f9:26:35:6e:73 +d7:21:4d:fe:43:22 +63:13:3a:af:94:e9 +f3:11:3c:68:ef:5e +76:5a:06:33:31:fe +63:d9:b8:ef:ec:36 +3b:f3:4d:c4:22:e6 +d0:a2:cb:f9:f1:0b +95:0e:76:bc:99:ee +ae:e7:64:d9:ce:5b +ff:5a:6f:a2:26:9a +75:96:d4:72:db:49 +a8:ac:2a:2a:23:67 +db:4e:14:4d:b1:7c +45:fd:c8:52:05:cf +91:7b:e7:6e:23:07 +71:50:0c:46:78:3d +a9:90:9b:c0:b4:fc +47:0e:9a:82:af:48 +e8:1c:cf:c0:16:d1 +e1:6a:42:25:89:c3 +\N +55:8e:63:3b:44:c8 +93:8a:78:62:38:70 +29:81:d2:3d:12:80 +3e:d1:1e:94:2f:5d +fb:8c:c4:ee:84:7c +\N +cc:ad:28:56:b2:4a +52:f6:13:94:b7:03 +a2:8d:f8:f9:f8:c0 +57:68:00:9c:1b:f8 +a6:e2:31:88:8a:b4 +41:f7:0a:bd:47:08 +bf:5c:7d:64:08:73 +33:cc:60:43:05:e1 +cd:a5:a8:b0:99:14 +ef:fd:75:f1:3e:99 +b8:b0:b8:85:80:53 +7b:1c:fc:5c:b2:c8 +92:38:0c:df:81:57 +1e:ab:d4:18:c5:3a +b0:a1:c6:88:a3:29 +c7:37:ec:30:2b:7c +5e:5b:32:94:60:f7 +9d:ab:93:1f:de:1d +ff:32:af:ef:10:2e +f8:54:03:77:0d:e0 +49:e4:f8:f7:63:41 +18:f7:95:42:ea:32 +f8:a2:40:af:9e:af +1d:e2:71:c3:be:6e +\N +6a:38:d7:a5:b7:cd +df:51:52:74:c6:d4 +f2:05:5e:d2:1e:f3 +85:a7:b9:dd:80:72 +ae:ad:f5:1f:d1:7e +cf:71:9a:9c:b4:4d +\N +ac:8d:0f:5b:63:21 +c4:f0:3e:23:9e:7d +45:91:19:00:06:fa +c6:b6:30:24:e2:c5 +48:e1:e1:4a:8f:99 +cd:74:2c:39:14:e3 +9b:bb:32:10:ec:14 +a5:3c:a6:c9:64:14 +bc:ea:9c:03:76:75 +d5:29:75:05:8a:5d +\N +37:92:8f:cb:f1:e5 +e5:eb:1b:0e:02:58 +9f:9c:a2:22:a4:25 +26:f4:f4:e6:b8:cb +dd:79:87:70:0b:e7 +80:87:95:20:cd:ce +0d:28:2a:d1:0f:e2 +05:b8:34:36:55:b0 +89:03:74:cd:43:a9 +74:10:93:21:1e:04 +27:bb:a9:3a:7b:f0 +73:3c:06:b1:51:ad +47:0e:59:c0:5d:38 +13:13:e1:1c:aa:25 +4a:31:57:23:9b:54 +e2:cc:11:0d:3a:a5 +a9:2b:32:79:3e:60 +53:1c:b9:1d:db:c7 +\N +70:8a:83:2b:c0:23 +4c:55:af:1e:79:f9 +b9:4c:7c:39:c1:ee +c5:83:ab:17:63:50 +b4:cf:fc:c4:fe:db +12:33:a4:22:4e:a4 +99:db:22:10:3f:ae +f4:31:5b:3a:26:c4 +\N +db:a5:1a:67:bf:b5 +9c:c6:3f:59:ec:96 +8f:52:b2:83:41:b4 +49:ac:2a:44:a4:28 +0c:51:53:4e:10:79 +e5:54:31:9d:51:d9 +d0:8d:79:bd:4f:a1 +ee:ba:f1:4f:a1:bc +76:25:97:80:8b:a7 +3a:dd:50:3b:82:d0 +34:8d:ca:fd:24:fc +2f:f9:aa:93:0e:70 +93:29:d0:c2:7a:cb +3a:a8:a7:c9:9c:5b +8f:6c:0b:a1:1a:22 +ce:4a:b7:a6:59:9e +\N +\N +e5:bd:83:62:cb:59 +ba:d9:ed:2f:68:58 +48:18:7a:6c:cc:2f +76:03:b0:d3:ae:9d +ef:3c:db:66:d9:82 +2d:73:91:dd:fb:69 +33:35:c3:7d:50:49 +50:a3:e9:24:18:32 +66:eb:ab:3a:14:2e +a9:13:53:36:ee:95 +1f:4f:b4:57:34:0a +60:26:2c:17:5c:d8 +01:43:b5:79:eb:0f +c0:94:5d:b5:41:2c +fb:e6:51:d6:49:9c +87:7a:23:90:e9:df +78:52:28:a5:f9:1f +38:b2:03:d7:5d:b3 +bf:b5:5e:99:80:9f +7c:8f:73:5c:07:95 +ba:b8:6b:d2:ef:ab +9f:25:81:eb:33:0a +82:cb:7c:44:6a:5f +ca:46:2b:3c:cf:7f +17:64:2a:89:cf:59 +\N +35:59:4c:9d:5a:0d +c9:5e:a4:dd:bb:ae +d0:90:56:ef:30:05 +bd:2d:22:41:42:5e +be:49:c2:de:66:22 +21:cb:55:17:01:c8 +22:00:5c:e5:9b:0d +23:c8:5f:22:33:ca +01:02:37:05:4f:36 +91:ba:08:fd:9e:ed +bf:ad:23:1f:3e:4d +c4:a6:c5:bd:89:dc +b9:13:9f:85:d9:fa +7d:b2:c9:07:4f:bc +\N +7a:84:d0:53:46:30 +f7:32:0c:87:f0:2f +77:15:22:cd:68:a0 +17:f9:26:35:6e:73 +d7:21:4d:fe:43:22 +63:13:3a:af:94:e9 +f3:11:3c:68:ef:5e +76:5a:06:33:31:fe +63:d9:b8:ef:ec:36 +3b:f3:4d:c4:22:e6 +d0:a2:cb:f9:f1:0b +95:0e:76:bc:99:ee +ae:e7:64:d9:ce:5b +ff:5a:6f:a2:26:9a +75:96:d4:72:db:49 +a8:ac:2a:2a:23:67 +db:4e:14:4d:b1:7c +45:fd:c8:52:05:cf +91:7b:e7:6e:23:07 +71:50:0c:46:78:3d +a9:90:9b:c0:b4:fc +47:0e:9a:82:af:48 +e8:1c:cf:c0:16:d1 +e1:6a:42:25:89:c3 +\N +55:8e:63:3b:44:c8 +93:8a:78:62:38:70 +29:81:d2:3d:12:80 +3e:d1:1e:94:2f:5d +fb:8c:c4:ee:84:7c +\N +cc:ad:28:56:b2:4a +52:f6:13:94:b7:03 +a2:8d:f8:f9:f8:c0 +57:68:00:9c:1b:f8 +a6:e2:31:88:8a:b4 +41:f7:0a:bd:47:08 +bf:5c:7d:64:08:73 +33:cc:60:43:05:e1 +cd:a5:a8:b0:99:14 +ef:fd:75:f1:3e:99 +b8:b0:b8:85:80:53 +7b:1c:fc:5c:b2:c8 +92:38:0c:df:81:57 +1e:ab:d4:18:c5:3a +b0:a1:c6:88:a3:29 +c7:37:ec:30:2b:7c +5e:5b:32:94:60:f7 +9d:ab:93:1f:de:1d +ff:32:af:ef:10:2e +f8:54:03:77:0d:e0 +49:e4:f8:f7:63:41 +18:f7:95:42:ea:32 +f8:a2:40:af:9e:af +1d:e2:71:c3:be:6e +\N +6a:38:d7:a5:b7:cd +df:51:52:74:c6:d4 +f2:05:5e:d2:1e:f3 +85:a7:b9:dd:80:72 +ae:ad:f5:1f:d1:7e +cf:71:9a:9c:b4:4d +\N +ac:8d:0f:5b:63:21 +c4:f0:3e:23:9e:7d +45:91:19:00:06:fa +c6:b6:30:24:e2:c5 +48:e1:e1:4a:8f:99 +cd:74:2c:39:14:e3 +9b:bb:32:10:ec:14 +a5:3c:a6:c9:64:14 +bc:ea:9c:03:76:75 +d5:29:75:05:8a:5d +\N +37:92:8f:cb:f1:e5 +e5:eb:1b:0e:02:58 +9f:9c:a2:22:a4:25 +26:f4:f4:e6:b8:cb +dd:79:87:70:0b:e7 +80:87:95:20:cd:ce +0d:28:2a:d1:0f:e2 +05:b8:34:36:55:b0 +89:03:74:cd:43:a9 +74:10:93:21:1e:04 +27:bb:a9:3a:7b:f0 +73:3c:06:b1:51:ad +47:0e:59:c0:5d:38 +13:13:e1:1c:aa:25 diff --git a/contrib/btree_gist/data/numeric.data b/contrib/btree_gist/data/numeric.data new file mode 100644 index 0000000..58d76fa --- /dev/null +++ b/contrib/btree_gist/data/numeric.data @@ -0,0 +1,11 @@ +-1890.000000000000000000000000000000000000000000000000000000000000000000000000001 +-1889.999999999999999999999999999999999999999999999999999999999999999999999999999 +123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 +123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567891 +123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567892 +10000 +0 +0 +0 +NaN +NaN diff --git a/contrib/btree_gist/data/text.data b/contrib/btree_gist/data/text.data new file mode 100644 index 0000000..4494936 --- /dev/null +++ b/contrib/btree_gist/data/text.data @@ -0,0 +1 @@ +2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 diff --git a/contrib/btree_gist/data/time.data b/contrib/btree_gist/data/time.data new file mode 100644 index 0000000..6c567c7 --- /dev/null +++ b/contrib/btree_gist/data/time.data @@ -0,0 +1,599 @@ +23:56:29 +14:23:32 +15:46:58 +\N +18:47:20 +11:54:06 +08:35:07 +06:37:29 +11:27:58 +\N +14:05:32 +17:18:35 +20:40:36 +01:53:24 +06:30:54 +08:55:08 +14:09:40 +19:45:28 +18:56:29 +\N +03:07:47 +20:07:06 +08:54:31 +03:48:12 +14:58:09 +04:23:51 +04:35:11 +17:51:38 +04:19:35 +14:54:46 +03:31:30 +17:03:30 +01:52:27 +07:45:51 +10:30:45 +14:55:59 +02:30:42 +04:28:11 +10:57:11 +12:47:13 +14:37:11 +15:47:57 +20:59:33 +15:51:53 +18:28:37 +16:24:13 +06:58:48 +20:58:13 +22:05:01 +13:20:20 +13:46:46 +08:06:45 +03:56:45 +00:48:10 +16:15:59 +05:39:04 +21:11:01 +18:57:40 +06:28:28 +07:09:17 +09:35:47 +07:08:00 +12:02:01 +00:32:50 +23:06:16 +02:57:27 +08:50:33 +18:40:40 +12:51:38 +19:34:22 +00:37:59 +09:39:35 +\N +\N +01:36:43 +\N +12:58:39 +06:53:03 +05:14:10 +04:02:08 +04:40:02 +\N +15:03:29 +20:25:02 +12:19:17 +13:47:39 +09:53:23 +06:23:25 +05:56:20 +14:18:24 +14:02:34 +12:27:36 +09:31:29 +13:35:03 +17:47:47 +17:55:57 +06:30:39 +06:21:38 +16:55:11 +01:49:01 +22:16:13 +12:17:35 +11:25:40 +\N +00:29:46 +07:37:36 +\N +14:52:12 +10:49:02 +18:40:02 +\N +02:58:13 +21:33:44 +16:52:33 +01:40:26 +08:15:03 +05:20:44 +09:43:11 +\N +19:34:51 +07:51:41 +04:20:43 +13:20:32 +20:30:08 +13:50:55 +00:44:30 +06:13:26 +03:29:43 +00:19:51 +05:11:23 +20:48:53 +12:52:42 +09:41:18 +03:45:21 +16:13:59 +06:19:58 +17:17:55 +18:28:12 +19:58:59 +03:25:07 +06:50:23 +23:00:13 +\N +03:52:47 +21:13:06 +\N +15:36:11 +12:36:08 +07:56:23 +23:32:03 +\N +15:23:39 +21:20:05 +04:44:09 +22:48:19 +21:44:28 +02:17:10 +23:12:24 +12:38:57 +05:47:43 +23:17:09 +15:27:41 +02:04:03 +\N +18:11:40 +06:54:54 +20:57:42 +01:14:59 +02:45:54 +22:51:42 +01:00:42 +04:29:29 +13:41:28 +14:36:19 +22:25:02 +23:08:45 +04:50:50 +01:44:02 +12:37:17 +03:40:05 +15:31:07 +\N +00:32:35 +13:11:45 +18:05:35 +23:15:08 +01:52:35 +\N +18:46:10 +20:06:36 +16:17:06 +17:47:39 +02:54:56 +20:42:39 +08:00:44 +23:53:40 +\N +\N +10:24:10 +15:46:42 +20:23:26 +20:12:43 +\N +12:21:58 +17:52:22 +01:33:40 +15:55:22 +01:33:07 +17:46:27 +17:10:28 +00:39:40 +\N +17:30:25 +22:48:37 +23:45:32 +23:45:59 +17:27:33 +13:23:46 +09:34:22 +16:59:06 +09:19:23 +16:06:27 +01:03:41 +06:10:45 +11:45:10 +\N +23:30:22 +\N +12:19:21 +09:06:09 +22:14:02 +22:30:58 +17:38:16 +06:07:40 +12:38:59 +02:39:50 +00:14:12 +01:09:47 +05:16:45 +17:47:53 +13:23:16 +23:54:39 +23:26:01 +03:14:19 +03:36:47 +\N +15:49:11 +16:30:21 +06:31:21 +09:46:53 +17:48:40 +23:07:33 +09:30:58 +03:01:28 +18:48:39 +\N +10:20:37 +18:03:26 +23:38:14 +11:12:46 +00:39:00 +05:15:56 +06:07:20 +16:32:30 +08:42:21 +03:10:56 +06:03:47 +12:57:58 +21:42:59 +17:12:12 +00:08:11 +08:05:07 +03:45:59 +16:55:19 +12:47:20 +12:49:35 +03:48:21 +11:32:33 +11:30:51 +09:11:06 +03:02:36 +02:23:03 +02:16:44 +17:16:26 +07:04:20 +13:29:28 +21:01:12 +06:35:03 +02:23:14 +10:53:45 +06:06:18 +13:40:10 +09:27:36 +\N +07:00:44 +04:22:42 +\N +12:50:38 +23:03:05 +10:32:59 +20:54:04 +\N +07:53:27 +15:00:51 +\N +15:30:20 +15:27:57 +06:01:36 +22:20:26 +01:21:20 +05:54:01 +09:31:20 +19:54:37 +19:06:34 +18:35:22 +22:44:32 +12:43:45 +04:24:22 +03:26:29 +22:06:36 +15:03:19 +06:20:33 +05:37:36 +18:59:04 +10:59:54 +\N +17:04:29 +\N +08:51:37 +02:47:04 +11:17:51 +01:36:35 +07:23:02 +21:01:14 +21:07:23 +15:58:20 +03:37:48 +17:43:22 +08:06:10 +03:21:13 +14:23:04 +00:15:56 +12:30:28 +04:51:05 +22:47:38 +04:29:31 +00:38:02 +00:16:09 +07:38:35 +03:55:56 +12:06:21 +07:46:45 +10:31:07 +12:13:46 +06:55:31 +00:58:12 +14:46:31 +07:28:15 +21:43:37 +02:10:16 +07:30:34 +19:05:11 +13:54:34 +04:03:22 +\N +07:49:42 +02:53:33 +01:08:33 +09:42:32 +17:56:28 +17:37:54 +02:02:52 +07:43:47 +23:07:36 +\N +21:43:23 +04:34:38 +06:17:36 +23:16:48 +19:55:50 +05:55:45 +16:49:59 +17:50:54 +11:52:36 +20:21:19 +08:48:56 +11:18:58 +06:28:01 +03:02:25 +15:28:12 +12:26:01 +20:02:07 +14:30:34 +09:43:31 +11:44:00 +20:06:06 +17:44:33 +11:53:21 +20:26:36 +07:04:27 +13:13:37 +14:56:54 +10:18:04 +05:37:29 +\N +23:17:09 +04:50:14 +00:56:52 +09:20:10 +21:09:49 +11:10:24 +13:58:05 +23:14:01 +\N +20:00:56 +11:43:43 +08:43:58 +\N +\N +15:44:40 +19:38:12 +23:26:57 +05:53:18 +12:51:41 +18:03:27 +22:57:21 +10:57:10 +\N +15:56:10 +14:41:42 +04:04:38 +\N +07:49:13 +20:08:21 +17:37:16 +11:31:02 +\N +08:47:52 +20:19:41 +08:10:03 +02:45:28 +15:43:13 +\N +18:02:24 +19:21:57 +07:24:41 +20:08:46 +22:19:29 +21:22:15 +07:40:41 +\N +01:44:27 +13:22:27 +23:03:59 +17:46:43 +23:06:32 +19:55:27 +04:24:35 +03:50:26 +01:43:48 +17:05:49 +00:51:15 +18:17:56 +10:01:57 +13:16:32 +16:28:12 +05:36:40 +09:35:09 +\N +\N +04:36:40 +\N +09:31:47 +10:21:54 +07:49:09 +19:51:28 +14:02:25 +07:54:40 +20:26:20 +09:50:27 +19:05:44 +\N +11:43:30 +00:25:16 +05:07:26 +13:38:21 +19:48:53 +01:11:45 +07:06:48 +\N +21:17:06 +\N +17:33:35 +23:22:58 +21:47:12 +20:50:30 +01:04:16 +19:25:47 +22:57:00 +09:15:33 +\N +02:29:36 +21:27:15 +13:29:22 +\N +02:10:34 +06:14:24 +14:04:25 +03:37:23 +21:36:37 +15:41:07 +03:40:25 +15:51:36 +05:10:09 +18:54:02 +16:49:50 +03:18:24 +23:13:58 +05:55:06 +22:21:51 +02:23:28 +07:12:18 +02:33:13 +10:23:41 +\N +05:44:10 +21:59:24 +00:22:35 +23:07:01 +22:25:59 +13:25:35 +08:44:13 +04:25:14 +\N +14:04:18 +11:05:27 +13:42:39 +\N +05:24:12 +01:01:47 +07:49:06 +19:07:56 +03:35:35 +07:28:30 +05:00:13 +16:27:26 +00:14:42 +02:57:18 +23:39:57 +07:31:16 +19:08:03 +13:26:21 +11:39:43 +21:07:04 +03:30:59 +07:59:10 +14:50:17 +02:57:29 +23:37:36 +07:48:10 +17:04:36 +13:24:45 +23:42:26 +04:31:37 +21:09:05 +07:47:28 +13:18:23 +00:45:21 +03:30:56 +10:09:02 +14:02:41 +23:11:51 +03:34:54 +\N +02:20:03 +04:46:49 +06:12:58 +01:26:47 +01:33:06 +10:55:32 +16:14:38 +21:54:21 +20:59:06 +12:26:22 +19:34:40 +11:48:58 +14:32:43 +11:36:17 +06:57:47 +15:34:23 +02:56:30 +12:30:59 +11:33:55 +04:53:09 +00:01:24 +02:14:43 +\N +14:26:05 +18:48:04 diff --git a/contrib/btree_gist/data/timestamp.data b/contrib/btree_gist/data/timestamp.data new file mode 100644 index 0000000..065bc50 --- /dev/null +++ b/contrib/btree_gist/data/timestamp.data @@ -0,0 +1,624 @@ +2019-11-22 23:56:29 +1995-05-20 14:23:32 +1989-04-12 15:46:58 +\N +2023-10-21 18:47:20 +2028-11-27 11:54:06 +2024-05-24 08:35:07 +2018-08-31 06:37:29 +1988-07-16 11:27:58 +\N +2019-05-21 14:05:32 +1972-12-12 17:18:35 +1975-05-07 20:40:36 +2022-08-11 01:53:24 +1975-06-27 06:30:54 +2004-10-26 08:55:08 +1983-05-14 14:09:40 +2015-06-20 19:45:28 +1978-02-17 18:56:29 +\N +1970-12-04 03:07:47 +1977-03-22 20:07:06 +2032-10-28 08:54:31 +2004-03-02 03:48:12 +1992-10-29 14:58:09 +2021-05-05 04:23:51 +2025-06-25 04:35:11 +2036-07-15 17:51:38 +1981-03-10 04:19:35 +2012-12-04 14:54:46 +1996-02-02 03:31:30 +1992-12-31 17:03:30 +2003-02-03 01:52:27 +2008-12-15 07:45:51 +1994-11-19 10:30:45 +2036-09-20 14:55:59 +2034-10-21 02:30:42 +2019-11-16 04:28:11 +1995-01-23 10:57:11 +1974-10-11 12:47:13 +2027-02-26 14:37:11 +2027-08-08 15:47:57 +2037-08-30 20:59:33 +2026-01-08 15:51:53 +2023-09-18 18:28:37 +2012-03-07 16:24:13 +2011-08-29 06:58:48 +1979-11-06 20:58:13 +2033-09-25 22:05:01 +1986-06-08 13:20:20 +2020-01-13 13:46:46 +2015-09-19 08:06:45 +2035-11-16 03:56:45 +1985-11-12 00:48:10 +2002-05-26 16:15:59 +2002-01-30 05:39:04 +1980-01-26 21:11:01 +2037-03-23 18:57:40 +2016-02-23 06:28:28 +2023-04-21 07:09:17 +2033-04-11 09:35:47 +1985-09-09 07:08:00 +1993-01-29 12:02:01 +2015-06-28 00:32:50 +2036-04-06 23:06:16 +2031-12-08 02:57:27 +2014-02-26 08:50:33 +1994-01-23 18:40:40 +2019-01-27 12:51:38 +1978-08-01 19:34:22 +1979-05-21 00:37:59 +2022-12-12 09:39:35 +\N +\N +2007-10-16 01:36:43 +\N +2037-05-17 12:58:39 +2034-08-14 06:53:03 +2014-12-20 05:14:10 +2033-03-13 04:02:08 +2010-10-03 04:40:02 +\N +1992-12-23 15:03:29 +2029-05-15 20:25:02 +1993-07-17 12:19:17 +2007-11-06 13:47:39 +2024-10-22 09:53:23 +2019-03-02 06:23:25 +2026-07-24 05:56:20 +1973-03-29 14:18:24 +2006-06-02 14:02:34 +2032-06-11 12:27:36 +1990-01-28 09:31:29 +2019-06-16 13:35:03 +1970-04-21 17:47:47 +2012-09-17 17:55:57 +1993-10-06 06:30:39 +1993-02-24 06:21:38 +2014-12-07 16:55:11 +2018-09-17 01:49:01 +2015-05-22 22:16:13 +1983-01-19 12:17:35 +1978-11-08 11:25:40 +\N +2021-06-01 00:29:46 +1970-11-19 07:37:36 +\N +2030-06-12 14:52:12 +2035-08-11 10:49:02 +2021-01-31 18:40:02 +\N +1996-06-25 02:58:13 +1974-11-28 21:33:44 +1989-04-28 16:52:33 +1998-07-17 01:40:26 +2029-09-14 08:15:03 +2010-01-06 05:20:44 +2013-05-04 09:43:11 +\N +2023-10-03 19:34:51 +1998-02-06 07:51:41 +1984-07-16 04:20:43 +2008-01-11 13:20:32 +2015-06-23 20:30:08 +2026-04-02 13:50:55 +2021-11-26 00:44:30 +2012-07-09 06:13:26 +1975-01-07 03:29:43 +2022-12-04 00:19:51 +2013-01-22 05:11:23 +2001-02-13 20:48:53 +2001-11-20 12:52:42 +2008-12-27 09:41:18 +2030-07-05 03:45:21 +1970-07-22 16:13:59 +2037-07-11 06:19:58 +2034-12-24 17:17:55 +2022-04-04 18:28:12 +2018-03-24 19:58:59 +2037-03-25 03:25:07 +1972-06-24 06:50:23 +2034-08-15 23:00:13 +\N +2030-01-12 03:52:47 +2000-08-15 21:13:06 +\N +2034-07-25 15:36:11 +2030-04-06 12:36:08 +2003-08-22 07:56:23 +2012-04-17 23:32:03 +\N +1992-11-30 15:23:39 +2017-03-31 21:20:05 +2004-06-19 04:44:09 +1974-02-07 22:48:19 +1992-11-02 21:44:28 +2006-07-03 02:17:10 +2030-09-03 23:12:24 +1989-12-15 12:38:57 +1992-05-03 05:47:43 +1981-05-05 23:17:09 +1983-06-04 15:27:41 +2010-08-13 02:04:03 +\N +2022-06-15 18:11:40 +2011-03-10 06:54:54 +1973-11-06 20:57:42 +1998-03-22 01:14:59 +1992-07-20 02:45:54 +2022-01-15 22:51:42 +2022-05-03 01:00:42 +1972-06-08 04:29:29 +1976-10-27 13:41:28 +2023-12-13 14:36:19 +2027-08-01 22:25:02 +2009-05-04 23:08:45 +2021-03-19 04:50:50 +2025-04-09 01:44:02 +1988-07-28 12:37:17 +2023-07-31 03:40:05 +2003-07-25 15:31:07 +\N +1995-12-12 00:32:35 +1992-04-19 13:11:45 +1997-08-20 18:05:35 +2028-01-13 23:15:08 +1980-04-18 01:52:35 +\N +2030-03-08 18:46:10 +2000-03-22 20:06:36 +1987-03-17 16:17:06 +2008-03-10 17:47:39 +1982-04-02 02:54:56 +1970-01-29 20:42:39 +2032-03-28 08:00:44 +1991-10-03 23:53:40 +\N +\N +\N +2035-07-02 10:24:10 +1988-11-27 15:46:42 +2034-08-29 20:23:26 +2004-11-29 20:12:43 +\N +2013-08-28 12:21:58 +1997-04-06 17:52:22 +1994-10-12 01:33:40 +2027-06-18 15:55:22 +1971-01-10 01:33:07 +2035-02-23 17:46:27 +2036-10-25 17:10:28 +2033-06-29 00:39:40 +\N +2028-07-29 17:30:25 +2003-03-18 22:48:37 +1994-11-29 23:45:32 +2001-10-08 23:45:59 +2019-03-10 17:27:33 +2022-05-19 13:23:46 +1971-07-13 09:34:22 +1979-07-25 16:59:06 +1980-11-27 09:19:23 +2030-02-20 16:06:27 +1973-01-02 01:03:41 +1992-12-20 06:10:45 +2034-03-04 11:45:10 +\N +2036-11-27 23:30:22 +\N +2023-09-22 12:19:21 +2023-07-13 09:06:09 +1996-02-13 22:14:02 +1974-02-11 22:30:58 +1996-08-07 17:38:16 +1998-06-13 06:07:40 +2035-04-21 12:38:59 +1996-03-04 02:39:50 +2019-05-04 00:14:12 +2024-06-01 01:09:47 +2007-02-20 05:16:45 +2003-07-29 17:47:53 +2000-07-13 13:23:16 +2011-09-08 23:54:39 +2019-06-10 23:26:01 +1975-02-25 03:14:19 +2002-01-16 03:36:47 +\N +1986-04-08 15:49:11 +1986-03-08 16:30:21 +2019-06-21 06:31:21 +1988-09-19 09:46:53 +2035-11-30 17:48:40 +1986-11-27 23:07:33 +2037-03-10 09:30:58 +2030-07-15 03:01:28 +1988-06-29 18:48:39 +\N +1980-04-23 10:20:37 +2020-01-19 18:03:26 +2012-09-14 23:38:14 +1983-12-28 11:12:46 +1987-02-10 00:39:00 +2029-09-21 05:15:56 +1972-03-12 06:07:20 +2035-11-20 16:32:30 +1996-10-25 08:42:21 +1981-02-05 03:10:56 +2031-09-10 06:03:47 +1986-04-24 12:57:58 +1987-04-26 21:42:59 +2017-06-10 17:12:12 +1980-07-26 00:08:11 +2009-10-18 08:05:07 +1981-05-24 03:45:59 +2026-07-17 16:55:19 +2015-09-30 12:47:20 +2032-05-02 12:49:35 +1987-08-17 03:48:21 +2034-10-20 11:32:33 +2008-11-20 11:30:51 +1986-11-06 09:11:06 +1980-04-06 03:02:36 +1982-11-12 02:23:03 +1975-01-24 02:16:44 +2015-04-25 17:16:26 +1980-03-14 07:04:20 +1998-04-07 13:29:28 +2020-12-16 21:01:12 +2004-10-31 06:35:03 +1975-02-26 02:23:14 +2024-10-29 10:53:45 +1974-10-29 06:06:18 +1986-09-21 13:40:10 +2037-11-06 09:27:36 +\N +1979-06-02 07:00:44 +2001-06-28 04:22:42 +\N +2024-10-14 12:50:38 +2031-03-22 23:03:05 +1983-11-27 10:32:59 +1989-01-01 20:54:04 +\N +2037-03-05 07:53:27 +2002-12-28 15:00:51 +\N +2031-12-20 15:30:20 +2002-08-30 15:27:57 +1997-11-16 06:01:36 +2023-07-17 22:20:26 +2010-04-02 01:21:20 +2019-09-21 05:54:01 +1978-03-04 09:31:20 +1992-11-08 19:54:37 +2002-02-11 19:06:34 +2012-06-06 18:35:22 +2012-11-23 22:44:32 +1997-09-27 12:43:45 +1972-12-18 04:24:22 +1985-10-25 03:26:29 +2028-09-29 22:06:36 +1976-03-31 15:03:19 +1996-06-26 06:20:33 +2014-07-06 05:37:36 +2032-05-21 18:59:04 +2018-12-18 10:59:54 +\N +1974-06-02 17:04:29 +\N +2024-09-29 08:51:37 +1996-07-03 02:47:04 +1973-02-11 11:17:51 +2019-12-02 01:36:35 +2035-09-04 07:23:02 +2008-10-10 21:01:14 +2018-05-16 21:07:23 +2020-04-17 15:58:20 +2030-05-04 03:37:48 +2002-10-27 17:43:22 +2036-03-04 08:06:10 +2002-10-29 03:21:13 +2000-06-22 14:23:04 +1981-01-01 00:15:56 +infinity +infinity +infinity +infinity +infinity +infinity +infinity +infinity +2001-12-31 12:30:28 +2003-09-25 04:51:05 +2020-12-07 22:47:38 +2016-11-04 04:29:31 +2026-02-23 00:38:02 +1990-12-16 00:16:09 +2033-10-15 07:38:35 +2003-07-29 03:55:56 +1998-10-09 12:06:21 +2006-04-02 07:46:45 +1970-06-06 10:31:07 +2015-02-06 12:13:46 +2004-06-23 06:55:31 +2015-12-08 00:58:12 +2024-06-26 14:46:31 +1997-11-07 07:28:15 +2023-05-09 21:43:37 +1992-11-16 02:10:16 +2016-04-17 07:30:34 +1996-11-09 19:05:11 +2010-09-12 13:54:34 +2012-10-17 04:03:22 +\N +1998-07-19 07:49:42 +1973-11-11 02:53:33 +1992-11-15 01:08:33 +2032-04-22 09:42:32 +2031-09-14 17:56:28 +2005-03-25 17:37:54 +1993-03-17 02:02:52 +2004-03-01 07:43:47 +2009-10-06 23:07:36 +\N +1993-06-07 21:43:23 +1994-07-31 04:34:38 +1987-08-07 06:17:36 +2034-05-01 23:16:48 +2025-06-19 19:55:50 +2019-10-13 05:55:45 +1977-03-25 16:49:59 +1978-01-16 17:50:54 +2003-09-29 11:52:36 +2002-04-07 20:21:19 +2024-01-12 08:48:56 +1984-08-29 11:18:58 +2036-08-16 06:28:01 +1972-05-14 03:02:25 +2019-01-24 15:28:12 +2009-12-19 12:26:01 +1982-07-26 20:02:07 +2012-01-22 14:30:34 +1983-07-22 09:43:31 +1978-05-27 11:44:00 +1974-04-02 20:06:06 +2008-02-15 17:44:33 +2003-01-14 11:53:21 +1989-03-30 20:26:36 +2009-12-14 07:04:27 +2030-07-05 13:13:37 +2032-07-22 14:56:54 +2016-05-17 10:18:04 +2031-07-02 05:37:29 +\N +1980-07-28 23:17:09 +2031-09-06 04:50:14 +1975-01-20 00:56:52 +2019-05-05 09:20:10 +2025-05-02 21:09:49 +2001-12-27 11:10:24 +1991-09-27 13:58:05 +2021-12-14 23:14:01 +\N +2027-03-24 20:00:56 +2009-01-07 11:43:43 +1985-02-04 08:43:58 +\N +\N +1996-12-23 15:44:40 +2012-05-22 19:38:12 +1980-02-29 23:26:57 +2018-06-14 05:53:18 +1981-07-04 12:51:41 +1993-04-25 18:03:27 +2027-03-09 22:57:21 +1981-01-10 10:57:10 +\N +1974-06-16 15:56:10 +1985-10-15 14:41:42 +1988-01-11 04:04:38 +\N +1997-03-15 07:49:13 +1982-02-26 20:08:21 +1991-05-13 17:37:16 +2015-09-03 11:31:02 +\N +1987-06-05 08:47:52 +1971-03-29 20:19:41 +2002-03-28 08:10:03 +2032-03-25 02:45:28 +1983-07-23 15:43:13 +\N +1999-01-15 18:02:24 +2014-01-31 19:21:57 +2021-09-02 07:24:41 +1999-01-02 20:08:46 +2001-03-24 22:19:29 +2002-01-21 21:22:15 +2007-08-06 07:40:41 +\N +2032-09-07 01:44:27 +1984-11-22 13:22:27 +2035-06-18 23:03:59 +1994-07-29 17:46:43 +2023-04-20 23:06:32 +2010-02-17 19:55:27 +2014-08-23 04:24:35 +2017-02-08 03:50:26 +2036-10-24 01:43:48 +1994-11-14 17:05:49 +1979-04-19 00:51:15 +1973-10-09 18:17:56 +1999-01-17 10:01:57 +2012-07-08 13:16:32 +2012-12-03 16:28:12 +1980-11-22 05:36:40 +2002-02-28 09:35:09 +\N +\N +2023-03-01 04:36:40 +\N +1981-05-13 09:31:47 +2026-01-29 10:21:54 +2034-02-14 07:49:09 +2031-09-22 19:51:28 +1986-11-13 14:02:25 +2031-10-25 07:54:40 +2010-10-13 20:26:20 +2036-09-11 09:50:27 +2027-09-30 19:05:44 +\N +1990-07-28 11:43:30 +2001-05-05 00:25:16 +2029-01-10 05:07:26 +1972-10-09 13:38:21 +2012-03-25 19:48:53 +1987-04-06 01:11:45 +1998-06-04 07:06:48 +\N +2008-12-26 21:17:06 +\N +1979-04-23 17:33:35 +2010-01-16 23:22:58 +1982-07-23 21:47:12 +2013-08-21 20:50:30 +1982-12-23 01:04:16 +1997-04-03 19:25:47 +1986-02-20 22:57:00 +2034-09-08 09:15:33 +\N +1999-05-14 02:29:36 +1989-11-18 21:27:15 +1987-09-17 13:29:22 +\N +1978-05-03 02:10:34 +2005-05-22 06:14:24 +2001-02-11 14:04:25 +1980-07-28 03:37:23 +1984-04-11 21:36:37 +2010-06-02 15:41:07 +2023-09-05 03:40:25 +2020-12-29 15:51:36 +1997-06-06 05:10:09 +2005-10-01 18:54:02 +2023-01-17 16:49:50 +2013-04-27 03:18:24 +2018-05-23 23:13:58 +2022-11-23 05:55:06 +1971-05-09 22:21:51 +1997-12-05 02:23:28 +2008-08-22 07:12:18 +2025-05-23 02:33:13 +1989-02-18 10:23:41 +\N +2035-08-21 05:44:10 +1995-02-09 21:59:24 +1994-11-28 00:22:35 +1980-07-20 23:07:01 +1998-09-02 22:25:59 +1993-01-20 13:25:35 +1979-12-21 08:44:13 +2010-03-05 04:25:14 +\N +1989-01-07 14:04:18 +2015-10-09 11:05:27 +2006-08-23 13:42:39 +\N +2003-04-27 05:24:12 +2029-03-21 01:01:47 +2030-09-08 07:49:06 +2022-05-05 19:07:56 +1993-10-22 03:35:35 +2031-04-01 07:28:30 +2015-03-10 05:00:13 +1988-12-08 16:27:26 +2004-07-07 00:14:42 +1978-01-11 02:57:18 +2013-09-28 23:39:57 +2030-02-25 07:31:16 +2036-09-15 19:08:03 +2019-07-16 13:26:21 +2034-09-05 11:39:43 +2003-11-07 21:07:04 +2000-10-02 03:30:59 +2002-09-19 07:59:10 +2016-03-16 14:50:17 +1986-02-06 02:57:29 +-infinity +-infinity +-infinity +-infinity +-infinity +-infinity +-infinity +-infinity +2018-07-07 23:37:36 +1972-02-07 07:48:10 +2001-05-06 17:04:36 +1996-10-05 13:24:45 +1995-12-26 23:42:26 +1990-05-13 04:31:37 +1983-03-10 21:09:05 +2011-08-03 07:47:28 +2029-01-26 13:18:23 +2022-04-24 00:45:21 +1973-09-03 03:30:56 +2002-09-19 10:09:02 +1982-04-30 14:02:41 +2023-11-30 23:11:51 +1992-05-13 03:34:54 +\N +1986-05-11 02:20:03 +1976-12-31 04:46:49 +2009-10-23 06:12:58 +2022-02-08 01:26:47 +1999-02-24 01:33:06 +2007-09-30 10:55:32 +1991-11-03 16:14:38 +1985-06-14 21:54:21 +1973-06-15 20:59:06 +1972-07-18 12:26:22 +2012-07-05 19:34:40 +1989-01-17 11:48:58 +1982-02-13 14:32:43 +1994-11-23 11:36:17 +2008-08-01 06:57:47 +2032-11-22 15:34:23 +1976-01-04 02:56:30 +infinity +infinity +infinity +infinity +infinity +infinity +infinity +infinity +2037-04-11 12:30:59 +2011-02-24 11:33:55 +1992-11-16 04:53:09 +2025-11-25 00:01:24 +2013-02-08 02:14:43 +\N +2002-05-13 14:26:05 +1983-10-15 18:48:04 diff --git a/contrib/btree_gist/data/timestamptz.data b/contrib/btree_gist/data/timestamptz.data new file mode 100644 index 0000000..7f07cdc --- /dev/null +++ b/contrib/btree_gist/data/timestamptz.data @@ -0,0 +1,618 @@ +\N +2002-08-30 15:27:57 GMT +1997-11-16 06:01:36 GMT-2 +\N +2010-04-02 01:21:20 GMT+2 +2019-09-21 05:54:01 GMT+6 +1978-03-04 09:31:20 GMT-9 +1992-11-08 19:54:37 GMT-4 +2002-02-11 19:06:34 GMT-1 +2012-06-06 18:35:22 GMT+3 +2012-11-23 22:44:32 GMT+3 +1997-09-27 12:43:45 GMT-2 +1972-12-18 04:24:22 GMT-11 +\N +2028-09-29 22:06:36 GMT+9 +1976-03-31 15:03:19 GMT-10 +1996-06-26 06:20:33 GMT-3 +2014-07-06 05:37:36 GMT+4 +2032-05-21 18:59:04 GMT+10 +2018-12-18 10:59:54 GMT+3 +1986-02-15 10:47:42 GMT-6 +1974-06-02 17:04:29 GMT-10 +2020-11-03 05:11:44 GMT+6 +2024-09-29 08:51:37 GMT+7 +1996-07-03 02:47:04 GMT-3 +1973-02-11 11:17:51 GMT-11 +2019-12-02 01:36:35 GMT+6 +2035-09-04 07:23:02 GMT+11 +\N +2018-05-16 21:07:23 GMT+5 +\N +2030-05-04 03:37:48 GMT+9 +2002-10-27 17:43:22 GMT +2036-03-04 08:06:10 GMT+11 +2002-10-29 03:21:13 GMT +2000-06-22 14:23:04 GMT-1 +1981-01-01 00:15:56 GMT-8 +2001-12-31 12:30:28 GMT-1 +2003-09-25 04:51:05 GMT +\N +2016-11-04 04:29:31 GMT+5 +2026-02-23 00:38:02 GMT+8 +\N +2033-10-15 07:38:35 GMT+10 +2003-07-29 03:55:56 GMT +1998-10-09 12:06:21 GMT-2 +2006-04-02 07:46:45 GMT+1 +1970-06-06 10:31:07 GMT-12 +2015-02-06 12:13:46 GMT+4 +2004-06-23 06:55:31 GMT+0 +2015-12-08 00:58:12 GMT+4 +2024-06-26 14:46:31 GMT+7 +1997-11-07 07:28:15 GMT-2 +\N +1992-11-16 02:10:16 GMT-4 +\N +1996-11-09 19:05:11 GMT-3 +2010-09-12 13:54:34 GMT+2 +2012-10-17 04:03:22 GMT+3 +2035-09-05 02:13:28 GMT+11 +1998-07-19 07:49:42 GMT-2 +1973-11-11 02:53:33 GMT-11 +1992-11-15 01:08:33 GMT-4 +2032-04-22 09:42:32 GMT+10 +2031-09-14 17:56:28 GMT+10 +2005-03-25 17:37:54 GMT+0 +1993-03-17 02:02:52 GMT-4 +2004-03-01 07:43:47 GMT+0 +2009-10-06 23:07:36 GMT+2 +1977-12-15 18:43:22 GMT-9 +1993-06-07 21:43:23 GMT-4 +\N +1987-08-07 06:17:36 GMT-6 +2034-05-01 23:16:48 GMT+11 +2025-06-19 19:55:50 GMT+8 +2019-10-13 05:55:45 GMT+6 +1977-03-25 16:49:59 GMT-9 +1978-01-16 17:50:54 GMT-9 +2003-09-29 11:52:36 GMT +\N +2024-01-12 08:48:56 GMT+7 +\N +2036-08-16 06:28:01 GMT+11 +1972-05-14 03:02:25 GMT-11 +2019-01-24 15:28:12 GMT+5 +2009-12-19 12:26:01 GMT+2 +1982-07-26 20:02:07 GMT-8 +2012-01-22 14:30:34 GMT+3 +1983-07-22 09:43:31 GMT-7 +1978-05-27 11:44:00 GMT-9 +1974-04-02 20:06:06 GMT-11 +2008-02-15 17:44:33 GMT+1 +2003-01-14 11:53:21 GMT +1989-03-30 20:26:36 GMT-5 +2009-12-14 07:04:27 GMT+2 +\N +\N +\N +2031-07-02 05:37:29 GMT+10 +2002-06-01 01:18:02 GMT-1 +1980-07-28 23:17:09 GMT-8 +2031-09-06 04:50:14 GMT+10 +1975-01-20 00:56:52 GMT-10 +\N +2025-05-02 21:09:49 GMT+8 +\N +1991-09-27 13:58:05 GMT-4 +\N +\N +2027-03-24 20:00:56 GMT+8 +2009-01-07 11:43:43 GMT+2 +1985-02-04 08:43:58 GMT-7 +\N +1982-11-28 07:25:38 GMT-7 +1996-12-23 15:44:40 GMT-2 +2012-05-22 19:38:12 GMT+3 +1980-02-29 23:26:57 GMT-8 +2018-06-14 05:53:18 GMT+5 +1981-07-04 12:51:41 GMT-8 +1993-04-25 18:03:27 GMT-4 +2027-03-09 22:57:21 GMT+8 +1981-01-10 10:57:10 GMT-8 +2005-11-25 19:03:21 GMT+1 +1974-06-16 15:56:10 GMT-10 +1985-10-15 14:41:42 GMT-6 +\N +2030-12-31 21:55:54 GMT+10 +1997-03-15 07:49:13 GMT-2 +1982-02-26 20:08:21 GMT-8 +1991-05-13 17:37:16 GMT-4 +2015-09-03 11:31:02 GMT+4 +1977-10-28 18:16:43 GMT-9 +1987-06-05 08:47:52 GMT-6 +1971-03-29 20:19:41 GMT-12 +2002-03-28 08:10:03 GMT-1 +2032-03-25 02:45:28 GMT+10 +1983-07-23 15:43:13 GMT-7 +2035-01-02 09:00:43 GMT+11 +1999-01-15 18:02:24 GMT-2 +2014-01-31 19:21:57 GMT+4 +2021-09-02 07:24:41 GMT+6 +1999-01-02 20:08:46 GMT-2 +2001-03-24 22:19:29 GMT-1 +2002-01-21 21:22:15 GMT-1 +2007-08-06 07:40:41 GMT+1 +1975-12-07 20:04:02 GMT-10 +2032-09-07 01:44:27 GMT+10 +1984-11-22 13:22:27 GMT-7 +2035-06-18 23:03:59 GMT+11 +1994-07-29 17:46:43 GMT-3 +2023-04-20 23:06:32 GMT+7 +2010-02-17 19:55:27 GMT+2 +2014-08-23 04:24:35 GMT+4 +2017-02-08 03:50:26 GMT+5 +2036-10-24 01:43:48 GMT+12 +1994-11-14 17:05:49 GMT-3 +1979-04-19 00:51:15 GMT-9 +1973-10-09 18:17:56 GMT-11 +1999-01-17 10:01:57 GMT-2 +2012-07-08 13:16:32 GMT+3 +\N +1980-11-22 05:36:40 GMT-8 +2002-02-28 09:35:09 GMT-1 +2025-11-10 01:29:26 GMT+8 +2005-03-24 03:31:43 GMT+0 +\N +1987-09-11 07:03:58 GMT-6 +\N +2026-01-29 10:21:54 GMT+8 +2034-02-14 07:49:09 GMT+11 +\N +\N +2031-10-25 07:54:40 GMT+10 +2010-10-13 20:26:20 GMT+2 +2036-09-11 09:50:27 GMT+12 +2027-09-30 19:05:44 GMT+8 +1995-04-10 19:58:12 GMT-3 +1990-07-28 11:43:30 GMT-5 +2001-05-05 00:25:16 GMT-1 +2029-01-10 05:07:26 GMT+9 +1972-10-09 13:38:21 GMT-11 +2012-03-25 19:48:53 GMT+3 +1987-04-06 01:11:45 GMT-6 +1998-06-04 07:06:48 GMT-2 +2038-01-16 08:56:45 GMT+12 +2008-12-26 21:17:06 GMT+2 +1981-08-23 10:06:56 GMT-8 +1979-04-23 17:33:35 GMT-9 +2010-01-16 23:22:58 GMT+2 +1982-07-23 21:47:12 GMT-8 +2013-08-21 20:50:30 GMT+3 +1982-12-23 01:04:16 GMT-7 +1997-04-03 19:25:47 GMT-2 +1986-02-20 22:57:00 GMT-6 +2034-09-08 09:15:33 GMT+11 +1975-04-02 17:16:48 GMT-10 +1999-05-14 02:29:36 GMT-2 +1989-11-18 21:27:15 GMT-5 +\N +2030-05-15 08:09:46 GMT+9 +1978-05-03 02:10:34 GMT-9 +2005-05-22 06:14:24 GMT+0 +2001-02-11 14:04:25 GMT-1 +1980-07-28 03:37:23 GMT-8 +1984-04-11 21:36:37 GMT-7 +2010-06-02 15:41:07 GMT+2 +2023-09-05 03:40:25 GMT+7 +2020-12-29 15:51:36 GMT+6 +1997-06-06 05:10:09 GMT-2 +2005-10-01 18:54:02 GMT+1 +2023-01-17 16:49:50 GMT+7 +2013-04-27 03:18:24 GMT+3 +2018-05-23 23:13:58 GMT+5 +2022-11-23 05:55:06 GMT+7 +1971-05-09 22:21:51 GMT-12 +\N +2008-08-22 07:12:18 GMT+2 +2025-05-23 02:33:13 GMT+8 +1989-02-18 10:23:41 GMT-5 +2006-05-03 15:10:12 GMT+1 +2035-08-21 05:44:10 GMT+11 +1995-02-09 21:59:24 GMT-3 +1994-11-28 00:22:35 GMT-3 +1980-07-20 23:07:01 GMT-8 +1998-09-02 22:25:59 GMT-2 +1993-01-20 13:25:35 GMT-4 +1979-12-21 08:44:13 GMT-8 +\N +2022-10-19 07:06:12 GMT+7 +\N +\N +2006-08-23 13:42:39 GMT+1 +2024-05-31 02:55:37 GMT+7 +2003-04-27 05:24:12 GMT +2029-03-21 01:01:47 GMT+9 +2030-09-08 07:49:06 GMT+9 +2022-05-05 19:07:56 GMT+6 +1993-10-22 03:35:35 GMT-4 +2031-04-01 07:28:30 GMT+10 +2015-03-10 05:00:13 GMT+4 +1988-12-08 16:27:26 GMT-5 +\N +\N +2013-09-28 23:39:57 GMT+3 +2030-02-25 07:31:16 GMT+9 +2036-09-15 19:08:03 GMT+12 +\N +2034-09-05 11:39:43 GMT+11 +2003-11-07 21:07:04 GMT +\N +2002-09-19 07:59:10 GMT +2016-03-16 14:50:17 GMT+4 +1986-02-06 02:57:29 GMT-6 +2018-07-07 23:37:36 GMT+5 +\N +2001-05-06 17:04:36 GMT-1 +1996-10-05 13:24:45 GMT-3 +1995-12-26 23:42:26 GMT-3 +\N +1983-03-10 21:09:05 GMT-7 +2011-08-03 07:47:28 GMT+3 +2029-01-26 13:18:23 GMT+9 +2022-04-24 00:45:21 GMT+6 +1973-09-03 03:30:56 GMT-11 +\N +1982-04-30 14:02:41 GMT-8 +2023-11-30 23:11:51 GMT+7 +1992-05-13 03:34:54 GMT-4 +2001-11-13 00:47:25 GMT-1 +1986-05-11 02:20:03 GMT-6 +\N +\N +2022-02-08 01:26:47 GMT+6 +1999-02-24 01:33:06 GMT-2 +2007-09-30 10:55:32 GMT+1 +1991-11-03 16:14:38 GMT-4 +1985-06-14 21:54:21 GMT-7 +1973-06-15 20:59:06 GMT-11 +1972-07-18 12:26:22 GMT-11 +\N +1989-01-17 11:48:58 GMT-5 +1982-02-13 14:32:43 GMT-8 +1994-11-23 11:36:17 GMT-3 +2008-08-01 06:57:47 GMT+2 +\N +1976-01-04 02:56:30 GMT-10 +2037-04-11 12:30:59 GMT+12 +2011-02-24 11:33:55 GMT+3 +1992-11-16 04:53:09 GMT-4 +2025-11-25 00:01:24 GMT+8 +2013-02-08 02:14:43 GMT+3 +2003-05-05 05:25:07 GMT +2002-05-13 14:26:05 GMT-1 +1983-10-15 18:48:04 GMT-7 +1995-01-07 19:03:41 GMT-3 +1986-11-19 05:35:15 GMT-6 +1991-04-09 21:07:05 GMT-4 +2011-01-03 05:09:25 GMT+2 +1974-12-06 19:39:43 GMT-10 +2000-11-12 19:05:27 GMT-1 +2006-01-31 04:14:52 GMT+1 +2004-07-01 01:25:07 GMT+0 +1978-06-04 03:51:35 GMT-9 +\N +2002-07-29 17:13:57 GMT-1 +1977-01-03 12:24:31 GMT-10 +1991-12-12 18:57:03 GMT-4 +1986-06-13 22:44:23 GMT-6 +2012-12-08 18:42:47 GMT+3 +\N +1977-10-01 22:10:45 GMT-9 +1994-10-26 07:10:14 GMT-3 +1997-01-11 02:26:04 GMT-2 +2013-11-28 22:50:57 GMT+3 +2016-07-14 09:05:32 GMT+4 +\N +1994-10-27 20:12:10 GMT-3 +2018-02-22 01:05:22 GMT+5 +2034-10-05 12:42:38 GMT+11 +2028-03-04 00:08:34 GMT+9 +2037-05-21 23:24:07 GMT+12 +2031-01-14 06:56:54 GMT+10 +2036-04-03 10:15:05 GMT+11 +2036-01-05 10:54:45 GMT+11 +1979-09-22 14:31:26 GMT-9 +\N +2027-08-13 08:28:38 GMT+8 +2005-11-17 13:26:47 GMT+1 +2028-02-23 18:32:03 GMT+9 +1998-06-17 16:08:12 GMT-2 +2024-03-02 13:53:12 GMT+7 +1991-02-24 19:52:40 GMT-5 +1973-11-23 22:00:24 GMT-11 +2004-03-18 17:04:06 GMT+0 +2033-08-13 19:45:25 GMT+10 +2031-04-23 15:11:59 GMT+10 +2009-12-31 01:57:02 GMT+2 +1982-11-10 21:58:20 GMT-7 +2010-10-07 04:13:26 GMT+2 +1982-05-18 11:15:30 GMT-8 +2010-09-28 14:05:51 GMT+2 +1986-01-10 21:00:43 GMT-6 +1997-03-20 05:04:03 GMT-2 +2019-11-15 09:43:14 GMT+6 +2017-09-06 00:45:47 GMT+5 +2026-08-04 01:10:21 GMT+8 +1992-01-20 08:03:40 GMT-4 +2010-11-21 02:58:16 GMT+2 +1974-03-27 16:19:28 GMT-11 +2025-04-12 09:52:38 GMT+7 +2014-09-14 22:11:22 GMT+4 +1978-09-27 23:47:35 GMT-9 +1985-10-29 21:31:25 GMT-6 +2018-07-07 00:50:47 GMT+5 +1989-08-31 01:29:41 GMT-5 +1971-01-10 05:35:01 GMT-12 +1983-05-28 15:52:19 GMT-7 +2036-11-29 15:30:27 GMT+12 +2022-01-24 17:56:31 GMT+6 +2023-06-09 07:37:51 GMT+7 +1989-06-08 04:26:44 GMT-5 +2023-11-15 01:11:44 GMT+7 +1997-04-16 06:19:03 GMT-2 +2021-12-18 16:37:32 GMT+6 +2009-10-07 21:30:12 GMT+2 +1994-01-29 03:07:14 GMT-4 +1991-05-26 12:45:10 GMT-4 +1984-10-01 17:18:39 GMT-7 +2034-01-04 01:22:45 GMT+11 +1977-03-15 11:46:55 GMT-9 +1990-11-22 14:57:16 GMT-5 +2003-03-15 06:11:50 GMT +1977-08-27 08:26:42 GMT-9 +1972-10-17 01:34:22 GMT-11 +2032-09-15 22:54:13 GMT+10 +1994-07-31 10:50:47 GMT-3 +2024-08-25 05:13:02 GMT+7 +2013-09-18 18:19:31 GMT+3 +\N +\N +1981-12-25 22:21:59 GMT-8 +\N +2008-10-31 04:45:33 GMT+2 +2013-02-02 02:15:09 GMT+3 +2018-10-18 12:56:11 GMT+5 +1978-11-07 15:17:16 GMT-9 +2037-01-19 01:13:16 GMT+12 +\N +2021-04-21 08:45:28 GMT+6 +2028-01-21 13:52:14 GMT+8 +2015-03-11 16:07:57 GMT+4 +2005-03-13 17:22:20 GMT+0 +2004-01-28 20:45:12 GMT+0 +1991-03-21 13:23:37 GMT-5 +2029-07-26 06:01:08 GMT+9 +infinity +infinity +infinity +infinity +infinity +infinity +2002-11-15 19:24:22 GMT +1987-05-02 16:25:01 GMT-6 +1999-04-01 05:54:41 GMT-2 +2034-03-18 02:35:05 GMT+11 +1998-07-08 21:50:27 GMT-2 +2015-06-08 05:27:05 GMT+4 +1999-05-16 03:11:42 GMT-2 +2017-10-29 15:46:32 GMT+5 +2037-06-14 02:45:44 GMT+12 +1997-11-29 16:30:09 GMT-2 +1993-02-26 22:47:39 GMT-4 +1998-12-04 16:43:34 GMT-2 +2025-08-14 16:29:42 GMT+8 +1982-07-31 16:54:13 GMT-8 +\N +2029-04-26 12:37:56 GMT+9 +2025-09-21 23:33:16 GMT+8 +\N +2017-06-24 03:39:14 GMT+5 +1990-11-17 19:15:50 GMT-5 +2014-03-30 15:02:02 GMT+4 +\N +2020-08-26 07:34:24 GMT+6 +1992-11-14 14:14:38 GMT-4 +2010-04-22 17:35:09 GMT+2 +2034-03-23 18:10:28 GMT+11 +1984-10-17 02:42:50 GMT-7 +2001-04-29 03:59:54 GMT-1 +1996-08-15 07:16:34 GMT-3 +infinity +infinity +infinity +infinity +infinity +infinity +\N +1974-02-10 02:40:01 GMT-11 +2033-03-28 21:51:56 GMT+10 +2004-07-20 07:26:40 GMT+0 +2017-07-25 17:26:58 GMT+5 +2025-12-12 13:27:04 GMT+8 +2021-10-01 01:30:40 GMT+6 +1986-11-23 18:40:24 GMT-6 +2025-10-28 20:22:31 GMT+8 +2021-04-23 14:09:07 GMT+6 +2002-03-22 12:22:14 GMT-1 +2013-01-18 08:22:38 GMT+3 +1988-06-29 03:31:44 GMT-5 +1976-04-19 18:45:58 GMT-10 +2008-01-09 11:25:14 GMT+1 +1998-11-13 14:35:23 GMT-2 +2033-12-18 16:43:16 GMT+11 +1983-07-06 14:11:03 GMT-7 +2017-07-23 00:18:04 GMT+5 +2037-01-27 05:35:21 GMT+12 +2004-09-14 14:29:32 GMT+0 +2035-11-11 14:27:23 GMT+11 +2021-05-09 15:44:42 GMT+6 +1987-11-02 15:56:40 GMT-6 +\N +2026-12-02 12:28:27 GMT+8 +1990-12-27 22:26:41 GMT-5 +\N +1987-07-11 01:54:54 GMT-6 +2029-11-27 10:59:35 GMT+9 +1990-04-16 21:11:47 GMT-5 +2023-05-11 10:45:45 GMT+7 +\N +2011-08-05 12:47:00 GMT+3 +1993-06-09 06:44:41 GMT-4 +1982-06-02 21:37:08 GMT-8 +2025-08-13 13:03:45 GMT+8 +1974-03-11 03:30:14 GMT-11 +2011-09-27 19:47:44 GMT+3 +1992-12-02 08:40:51 GMT-4 +2033-10-11 14:20:32 GMT+10 +1983-01-20 16:32:49 GMT-7 +2002-09-15 02:56:52 GMT +2006-09-27 11:45:29 GMT+1 +1997-06-29 05:54:17 GMT-2 +\N +1984-02-22 06:27:16 GMT-7 +1992-07-19 22:54:28 GMT-4 +1991-12-22 22:41:11 GMT-4 +1990-07-06 01:25:10 GMT-5 +1973-06-15 06:34:08 GMT-11 +1976-03-21 22:21:06 GMT-10 +1976-06-15 07:14:46 GMT-10 +-infinity +-infinity +-infinity +-infinity +-infinity +-infinity +1972-01-15 06:30:22 GMT-11 +1971-08-06 10:41:43 GMT-11 +1995-08-21 21:12:06 GMT-3 +2006-07-30 07:14:27 GMT+1 +2023-09-20 23:59:35 GMT+7 +2003-03-18 13:53:03 GMT +2008-06-18 05:31:10 GMT+2 +1993-06-07 06:55:33 GMT-4 +2036-08-28 00:46:01 GMT+12 +1970-05-11 08:36:31 GMT-12 +\N +2019-01-10 06:01:34 GMT+5 +1986-04-16 07:43:34 GMT-6 +2007-07-14 07:46:45 GMT+1 +2015-05-11 05:13:03 GMT+4 +2025-12-09 22:39:17 GMT+8 +\N +2012-11-18 03:02:25 GMT+3 +2022-08-08 02:56:37 GMT+7 +1988-10-20 06:54:55 GMT-5 +1985-02-21 08:46:49 GMT-7 +1996-05-22 09:18:01 GMT-3 +1976-10-07 09:21:50 GMT-10 +1981-08-22 18:22:24 GMT-8 +2035-08-31 17:58:57 GMT+11 +\N +\N +\N +2011-11-13 20:09:47 GMT+3 +2018-04-02 08:00:33 GMT+5 +1984-08-07 03:17:37 GMT-7 +1988-07-13 10:31:02 GMT-5 +\N +2029-08-28 23:46:32 GMT+9 +2008-12-10 12:40:01 GMT+2 +1974-01-10 13:11:31 GMT-11 +1996-06-17 05:23:30 GMT-3 +1974-06-05 10:42:56 GMT-10 +1975-02-19 03:03:35 GMT-10 +1994-06-29 10:30:45 GMT-3 +2018-07-08 13:28:04 GMT+5 +\N +1984-10-09 13:52:14 GMT-7 +2033-12-23 18:53:07 GMT+11 +2021-06-11 02:18:52 GMT+6 +2027-01-20 17:50:31 GMT+8 +2012-04-17 09:46:09 GMT+3 +1982-03-08 23:06:30 GMT-8 +2004-11-03 06:34:08 GMT+0 +2028-05-30 05:51:58 GMT+9 +1981-09-06 21:46:45 GMT-8 +2004-08-12 16:29:39 GMT+0 +1998-02-22 05:03:52 GMT-2 +2023-03-08 13:32:55 GMT+7 +1991-09-16 22:16:21 GMT-4 +\N +1999-07-18 22:54:50 GMT-2 +\N +1991-11-12 03:31:16 GMT-4 +1993-08-28 02:05:54 GMT-4 +2026-11-10 04:53:55 GMT+8 +2015-06-21 03:00:10 GMT+4 +2032-02-05 04:32:19 GMT+10 +1974-11-25 19:29:07 GMT-10 +1985-11-04 00:11:55 GMT-6 +1992-11-23 19:38:16 GMT-4 +1986-07-18 15:15:06 GMT-6 +1987-10-25 00:29:12 GMT-6 +1987-12-08 10:12:04 GMT-6 +1996-11-06 14:53:07 GMT-3 +2028-05-15 05:23:09 GMT+9 +1998-12-12 15:18:10 GMT-2 +1974-11-23 21:02:21 GMT-10 +2021-08-17 04:11:28 GMT+6 +2020-04-02 06:42:25 GMT+6 +\N +1994-07-01 07:43:54 GMT-3 +1989-03-09 09:10:29 GMT-5 +2008-04-06 08:50:48 GMT+1 +2027-02-23 20:30:36 GMT+8 +1983-10-09 05:19:36 GMT-7 +1995-10-16 11:47:58 GMT-3 +2007-09-09 12:43:09 GMT+1 +1977-12-16 00:24:08 GMT-9 +2008-04-05 21:05:40 GMT+1 +\N +1983-10-17 15:56:25 GMT-7 +2029-08-12 12:45:17 GMT+9 +1994-10-20 18:41:45 GMT-3 +2017-12-08 16:48:31 GMT+5 +2018-02-09 08:41:07 GMT+5 +1973-12-13 16:00:22 GMT-11 +2022-06-20 01:45:40 GMT+7 +2033-05-25 10:33:11 GMT+10 +2017-02-01 05:21:30 GMT+5 +2019-02-01 20:00:39 GMT+5 +1970-10-01 20:58:08 GMT-12 +2025-01-17 02:23:47 GMT+7 +1974-03-08 16:19:17 GMT-11 +2020-05-27 21:01:29 GMT+6 +1999-01-10 08:39:45 GMT-2 +2009-05-26 10:18:22 GMT+2 +2014-07-22 07:54:09 GMT+4 +2036-10-26 20:20:46 GMT+12 +2025-03-03 08:47:09 GMT+7 +1972-09-22 21:58:10 GMT-11 +1998-05-16 11:05:46 GMT-2 +1994-09-14 08:08:42 GMT-3 +1976-08-14 12:10:43 GMT-10 +1975-03-14 19:29:02 GMT-10 +1980-10-31 16:30:29 GMT-8 +1975-10-03 19:29:30 GMT-10 +2020-02-09 20:43:47 GMT+6 +1975-04-02 10:00:13 GMT-10 +2027-07-27 11:17:48 GMT+8 +2022-05-23 09:28:31 GMT+6 +1999-11-08 15:38:46 GMT-1 +2007-01-14 02:48:02 GMT+1 +2026-05-04 08:12:13 GMT+8 +2029-06-19 09:20:46 GMT+9 +2005-05-07 19:38:36 GMT+0 +2023-04-23 14:15:53 GMT+7 +2022-02-12 01:05:51 GMT+6 diff --git a/contrib/btree_gist/data/timetz.data b/contrib/btree_gist/data/timetz.data new file mode 100644 index 0000000..a179a1e --- /dev/null +++ b/contrib/btree_gist/data/timetz.data @@ -0,0 +1,599 @@ +15:27:57 GMT +06:01:36 GMT-2 +\N +01:21:20 GMT+2 +05:54:01 GMT+6 +09:31:20 GMT-9 +19:54:37 GMT-4 +19:06:34 GMT-1 +18:35:22 GMT+3 +22:44:32 GMT+3 +12:43:45 GMT-2 +04:24:22 GMT-11 +\N +22:06:36 GMT+9 +15:03:19 GMT-10 +06:20:33 GMT-3 +05:37:36 GMT+4 +18:59:04 GMT+10 +10:59:54 GMT+3 +10:47:42 GMT-6 +17:04:29 GMT-10 +05:11:44 GMT+6 +08:51:37 GMT+7 +02:47:04 GMT-3 +11:17:51 GMT-11 +01:36:35 GMT+6 +07:23:02 GMT+11 +\N +21:07:23 GMT+5 +\N +03:37:48 GMT+9 +17:43:22 GMT +08:06:10 GMT+11 +03:21:13 GMT +14:23:04 GMT-1 +00:15:56 GMT-8 +12:30:28 GMT-1 +04:51:05 GMT +\N +04:29:31 GMT+5 +00:38:02 GMT+8 +\N +07:38:35 GMT+10 +03:55:56 GMT +12:06:21 GMT-2 +07:46:45 GMT+3 +10:31:07 GMT-12 +12:13:46 GMT+4 +06:55:31 GMT+0 +00:58:12 GMT+4 +14:46:31 GMT+7 +07:28:15 GMT-2 +\N +02:10:16 GMT-4 +\N +19:05:11 GMT-3 +13:54:34 GMT+2 +04:03:22 GMT+3 +02:13:28 GMT+11 +07:49:42 GMT-2 +02:53:33 GMT-11 +01:08:33 GMT-4 +09:42:32 GMT+10 +17:56:28 GMT+10 +17:37:54 GMT+0 +02:02:52 GMT-4 +07:43:47 GMT+0 +23:07:36 GMT+2 +18:43:22 GMT-9 +21:43:23 GMT-4 +\N +06:17:36 GMT-6 +23:16:48 GMT+11 +19:55:50 GMT+8 +05:55:45 GMT+6 +16:49:59 GMT-9 +17:50:54 GMT-9 +11:52:36 GMT +\N +08:48:56 GMT+7 +\N +06:28:01 GMT+11 +03:02:25 GMT-11 +15:28:12 GMT+5 +12:26:01 GMT+2 +20:02:07 GMT-8 +14:30:34 GMT+3 +09:43:31 GMT-7 +11:44:00 GMT-9 +20:06:06 GMT-11 +17:44:33 GMT+1 +11:53:21 GMT +20:26:36 GMT-5 +07:04:27 GMT+2 +\N +\N +\N +05:37:29 GMT+10 +01:18:02 GMT-1 +23:17:09 GMT-8 +04:50:14 GMT+10 +00:56:52 GMT-10 +\N +21:09:49 GMT+8 +\N +13:58:05 GMT-4 +\N +\N +20:00:56 GMT+8 +11:43:43 GMT+2 +08:43:58 GMT-7 +\N +07:25:38 GMT-7 +15:44:40 GMT-2 +19:38:12 GMT+3 +23:26:57 GMT-8 +05:53:18 GMT+5 +12:51:41 GMT-8 +18:03:27 GMT-4 +22:57:21 GMT+8 +10:57:10 GMT-8 +19:03:21 GMT+1 +15:56:10 GMT-10 +14:41:42 GMT-6 +\N +21:55:54 GMT+10 +07:49:13 GMT-2 +20:08:21 GMT-8 +17:37:16 GMT-4 +11:31:02 GMT+4 +18:16:43 GMT-9 +08:47:52 GMT-6 +20:19:41 GMT-12 +08:10:03 GMT-1 +02:45:28 GMT+10 +15:43:13 GMT-7 +09:00:43 GMT+11 +18:02:24 GMT-2 +19:21:57 GMT+4 +07:24:41 GMT+6 +20:08:46 GMT-2 +22:19:29 GMT-1 +21:22:15 GMT-1 +07:40:41 GMT+1 +20:04:02 GMT-10 +01:44:27 GMT+10 +13:22:27 GMT-7 +23:03:59 GMT+11 +17:46:43 GMT-3 +23:06:32 GMT+7 +19:55:27 GMT+2 +04:24:35 GMT+4 +03:50:26 GMT+5 +01:43:48 GMT+12 +17:05:49 GMT-3 +00:51:15 GMT-9 +18:17:56 GMT-11 +10:01:57 GMT-2 +13:16:32 GMT+3 +\N +05:36:40 GMT-8 +09:35:09 GMT-1 +01:29:26 GMT+8 +03:31:43 GMT+0 +\N +07:03:58 GMT-6 +\N +10:21:54 GMT+8 +07:49:09 GMT+11 +\N +\N +07:54:40 GMT+10 +20:26:20 GMT+2 +09:50:27 GMT+12 +19:05:44 GMT+8 +19:58:12 GMT-3 +11:43:30 GMT-5 +00:25:16 GMT-1 +05:07:26 GMT+9 +13:38:21 GMT-11 +19:48:53 GMT+3 +01:11:45 GMT-6 +07:06:48 GMT-2 +08:56:45 GMT+12 +21:17:06 GMT+2 +10:06:56 GMT-8 +17:33:35 GMT-9 +23:22:58 GMT+2 +21:47:12 GMT-8 +20:50:30 GMT+3 +01:04:16 GMT-7 +19:25:47 GMT-2 +22:57:00 GMT-6 +09:15:33 GMT+11 +17:16:48 GMT-10 +02:29:36 GMT-2 +21:27:15 GMT-5 +\N +08:09:46 GMT+9 +02:10:34 GMT-9 +06:14:24 GMT+0 +14:04:25 GMT-1 +03:37:23 GMT-8 +21:36:37 GMT-7 +15:41:07 GMT+2 +03:40:25 GMT+7 +15:51:36 GMT+6 +05:10:09 GMT-2 +18:54:02 GMT+1 +16:49:50 GMT+7 +03:18:24 GMT+3 +23:13:58 GMT+5 +05:55:06 GMT+7 +22:21:51 GMT-12 +\N +07:12:18 GMT+2 +02:33:13 GMT+8 +10:23:41 GMT-5 +15:10:12 GMT+1 +05:44:10 GMT+11 +21:59:24 GMT-3 +00:22:35 GMT-3 +23:07:01 GMT-8 +22:25:59 GMT-2 +13:25:35 GMT-4 +08:44:13 GMT-8 +\N +07:06:12 GMT+7 +\N +\N +13:42:39 GMT+1 +02:55:37 GMT+7 +05:24:12 GMT +01:01:47 GMT+9 +07:49:06 GMT+9 +19:07:56 GMT+6 +03:35:35 GMT-4 +07:28:30 GMT+10 +05:00:13 GMT+4 +16:27:26 GMT-5 +\N +\N +23:39:57 GMT+3 +07:31:16 GMT+9 +19:08:03 GMT+12 +\N +11:39:43 GMT+11 +21:07:04 GMT +\N +07:59:10 GMT +14:50:17 GMT+4 +02:57:29 GMT-6 +23:37:36 GMT+5 +\N +17:04:36 GMT-1 +13:24:45 GMT-3 +23:42:26 GMT-3 +\N +21:09:05 GMT-7 +07:47:28 GMT+3 +13:18:23 GMT+9 +00:45:21 GMT+6 +03:30:56 GMT-11 +\N +14:02:41 GMT-8 +23:11:51 GMT+7 +03:34:54 GMT-4 +00:47:25 GMT-1 +02:20:03 GMT-6 +\N +\N +01:26:47 GMT+6 +01:33:06 GMT-2 +10:55:32 GMT+1 +16:14:38 GMT-4 +21:54:21 GMT-7 +20:59:06 GMT-11 +12:26:22 GMT-11 +\N +11:48:58 GMT-5 +14:32:43 GMT-8 +11:36:17 GMT-3 +06:57:47 GMT+2 +\N +02:56:30 GMT-10 +12:30:59 GMT+12 +11:33:55 GMT+3 +04:53:09 GMT-4 +00:01:24 GMT+8 +02:14:43 GMT+3 +05:25:07 GMT +14:26:05 GMT-1 +18:48:04 GMT-7 +19:03:41 GMT-3 +05:35:15 GMT-6 +21:07:05 GMT-4 +05:09:25 GMT+2 +19:39:43 GMT-10 +19:05:27 GMT-1 +04:14:52 GMT+1 +01:25:07 GMT+0 +03:51:35 GMT-9 +\N +17:13:57 GMT-1 +12:24:31 GMT-10 +18:57:03 GMT-4 +22:44:23 GMT-6 +18:42:47 GMT+3 +\N +22:10:45 GMT-9 +07:10:14 GMT-3 +02:26:04 GMT-2 +22:50:57 GMT+3 +09:05:32 GMT+4 +\N +20:12:10 GMT-3 +01:05:22 GMT+5 +12:42:38 GMT+11 +00:08:34 GMT+9 +23:24:07 GMT+12 +06:56:54 GMT+10 +10:15:05 GMT+11 +10:54:45 GMT+11 +14:31:26 GMT-9 +\N +08:28:38 GMT+8 +13:26:47 GMT+1 +18:32:03 GMT+9 +16:08:12 GMT-2 +13:53:12 GMT+7 +19:52:40 GMT-5 +22:00:24 GMT-11 +17:04:06 GMT+0 +19:45:25 GMT+10 +15:11:59 GMT+10 +01:57:02 GMT+2 +21:58:20 GMT-7 +04:13:26 GMT+2 +11:15:30 GMT-8 +14:05:51 GMT+2 +21:00:43 GMT-6 +05:04:03 GMT-2 +09:43:14 GMT+6 +00:45:47 GMT+5 +01:10:21 GMT+8 +08:03:40 GMT-4 +02:58:16 GMT+2 +16:19:28 GMT-11 +09:52:38 GMT+7 +22:11:22 GMT+4 +23:47:35 GMT-9 +21:31:25 GMT-6 +00:50:47 GMT+5 +01:29:41 GMT-5 +05:35:01 GMT-12 +15:52:19 GMT-7 +15:30:27 GMT+12 +17:56:31 GMT+6 +07:37:51 GMT+7 +04:26:44 GMT-5 +01:11:44 GMT+7 +06:19:03 GMT-2 +16:37:32 GMT+6 +21:30:12 GMT+2 +03:07:14 GMT-4 +12:45:10 GMT-4 +17:18:39 GMT-7 +01:22:45 GMT+11 +11:46:55 GMT-9 +14:57:16 GMT-5 +06:11:50 GMT +08:26:42 GMT-9 +01:34:22 GMT-11 +22:54:13 GMT+10 +10:50:47 GMT-3 +05:13:02 GMT+7 +18:19:31 GMT+3 +\N +\N +22:21:59 GMT-8 +\N +04:45:33 GMT+2 +02:15:09 GMT+3 +12:56:11 GMT+5 +15:17:16 GMT-9 +01:13:16 GMT+12 +\N +08:45:28 GMT+6 +13:52:14 GMT+8 +16:07:57 GMT+4 +17:22:20 GMT+0 +20:45:12 GMT+0 +13:23:37 GMT-5 +06:01:08 GMT+9 +19:24:22 GMT +16:25:01 GMT-6 +05:54:41 GMT-2 +02:35:05 GMT+11 +21:50:27 GMT-2 +05:27:05 GMT+4 +03:11:42 GMT-2 +15:46:32 GMT+5 +02:45:44 GMT+12 +16:30:09 GMT-2 +22:47:39 GMT-4 +16:43:34 GMT-2 +16:29:42 GMT+8 +16:54:13 GMT-8 +\N +12:37:56 GMT+9 +23:33:16 GMT+8 +\N +03:39:14 GMT+5 +19:15:50 GMT-5 +15:02:02 GMT+4 +\N +07:34:24 GMT+6 +14:14:38 GMT-4 +17:35:09 GMT+2 +18:10:28 GMT+11 +02:42:50 GMT-7 +03:59:54 GMT-1 +07:16:34 GMT-3 +\N +02:40:01 GMT-11 +21:51:56 GMT+10 +07:26:40 GMT+0 +17:26:58 GMT+5 +13:27:04 GMT+8 +01:30:40 GMT+6 +18:40:24 GMT-6 +20:22:31 GMT+8 +14:09:07 GMT+6 +12:22:14 GMT-1 +08:22:38 GMT+3 +03:31:44 GMT-5 +18:45:58 GMT-10 +11:25:14 GMT+1 +14:35:23 GMT-2 +16:43:16 GMT+11 +14:11:03 GMT-7 +00:18:04 GMT+5 +05:35:21 GMT+12 +14:29:32 GMT+0 +14:27:23 GMT+11 +15:44:42 GMT+6 +15:56:40 GMT-6 +\N +12:28:27 GMT+8 +22:26:41 GMT-5 +\N +01:54:54 GMT-6 +10:59:35 GMT+9 +21:11:47 GMT-5 +10:45:45 GMT+7 +\N +12:47:00 GMT+3 +06:44:41 GMT-4 +21:37:08 GMT-8 +13:03:45 GMT+8 +03:30:14 GMT-11 +19:47:44 GMT+3 +08:40:51 GMT-4 +14:20:32 GMT+10 +16:32:49 GMT-7 +02:56:52 GMT +11:45:29 GMT+1 +05:54:17 GMT-2 +\N +06:27:16 GMT-7 +22:54:28 GMT-4 +22:41:11 GMT-4 +01:25:10 GMT-5 +06:34:08 GMT-11 +22:21:06 GMT-10 +07:14:46 GMT-10 +06:30:22 GMT-11 +10:41:43 GMT-11 +21:12:06 GMT-3 +07:14:27 GMT+1 +23:59:35 GMT+7 +13:53:03 GMT +05:31:10 GMT+2 +06:55:33 GMT-4 +00:46:01 GMT+12 +08:36:31 GMT-12 +\N +06:01:34 GMT+5 +07:43:34 GMT-6 +07:46:45 GMT+1 +05:13:03 GMT+4 +22:39:17 GMT+8 +\N +03:02:25 GMT+3 +02:56:37 GMT+7 +06:54:55 GMT-5 +08:46:49 GMT-7 +09:18:01 GMT-3 +09:21:50 GMT-10 +18:22:24 GMT-8 +17:58:57 GMT+11 +\N +\N +\N +20:09:47 GMT+3 +08:00:33 GMT+5 +03:17:37 GMT-7 +10:31:02 GMT-5 +\N +23:46:32 GMT+9 +12:40:01 GMT+2 +13:11:31 GMT-11 +05:23:30 GMT-3 +10:42:56 GMT-10 +03:03:35 GMT-10 +10:30:45 GMT-3 +13:28:04 GMT+5 +\N +13:52:14 GMT-7 +18:53:07 GMT+11 +02:18:52 GMT+6 +17:50:31 GMT+8 +09:46:09 GMT+3 +23:06:30 GMT-8 +06:34:08 GMT+0 +05:51:58 GMT+9 +21:46:45 GMT-8 +16:29:39 GMT+0 +05:03:52 GMT-2 +13:32:55 GMT+7 +22:16:21 GMT-4 +\N +22:54:50 GMT-2 +\N +03:31:16 GMT-4 +02:05:54 GMT-4 +04:53:55 GMT+8 +03:00:10 GMT+4 +04:32:19 GMT+10 +19:29:07 GMT-10 +00:11:55 GMT-6 +19:38:16 GMT-4 +15:15:06 GMT-6 +00:29:12 GMT-6 +10:12:04 GMT-6 +14:53:07 GMT-3 +05:23:09 GMT+9 +15:18:10 GMT-2 +21:02:21 GMT-10 +04:11:28 GMT+6 +06:42:25 GMT+6 +\N +07:43:54 GMT-3 +09:10:29 GMT-5 +08:50:48 GMT+1 +20:30:36 GMT+8 +05:19:36 GMT-7 +11:47:58 GMT-3 +12:43:09 GMT+1 +00:24:08 GMT-9 +21:05:40 GMT+1 +\N +15:56:25 GMT-7 +12:45:17 GMT+9 +18:41:45 GMT-3 +16:48:31 GMT+5 +08:41:07 GMT+5 +16:00:22 GMT-11 +01:45:40 GMT+7 +10:33:11 GMT+10 +05:21:30 GMT+5 +20:00:39 GMT+5 +20:58:08 GMT-12 +02:23:47 GMT+7 +16:19:17 GMT-11 +21:01:29 GMT+6 +08:39:45 GMT-2 +10:18:22 GMT+2 +07:54:09 GMT+4 +20:20:46 GMT+12 +08:47:09 GMT+7 +21:58:10 GMT-11 +11:05:46 GMT-2 +08:08:42 GMT-3 +12:10:43 GMT-10 +19:29:02 GMT-10 +16:30:29 GMT-8 +19:29:30 GMT-10 +20:43:47 GMT+6 +10:00:13 GMT-10 +11:17:48 GMT+8 +09:28:31 GMT+6 +15:38:46 GMT-1 +02:48:02 GMT+1 +08:12:13 GMT+8 +09:20:46 GMT+9 +19:38:36 GMT+0 +14:15:53 GMT+7 +01:05:51 GMT+6 diff --git a/contrib/btree_gist/data/uuid.data b/contrib/btree_gist/data/uuid.data new file mode 100644 index 0000000..df118d3 --- /dev/null +++ b/contrib/btree_gist/data/uuid.data @@ -0,0 +1,703 @@ +5ad32d7e-b463-4363-a65f-52475d9fab27 +7787b66e-cf0e-48c2-b989-1e44e8a00891 +75ec8a55-afcf-442d-9e1d-f9d67a15caf9 +6f36f2e9-5e58-4961-9e8d-9c3ca1cfcd44 +78f6d184-f74e-4a38-81ce-a821e301e9ac +1aa4bf49-dd76-40df-a86c-393fd202b710 +98559f1d-00b3-417e-bc57-9053545a260d +ac24b4d7-1a8f-4abc-a02e-b3294497d18e +a425d99f-ee91-419a-8cd1-6908b8c89679 +815f3632-4d1b-42e3-8dbf-68a20e7fbea5 +ae212041-e64a-4ff1-b8c9-b922fc3f2087 +8e580963-0584-4391-9f1e-3e607d435bd8 +9348cf2f-fe8b-4f05-829e-e2f732482bcc +807b3ff5-0dac-46e1-ba10-07753ec4c7f5 +93325505-83f0-41f4-a060-0d6e1a166815 +cabeaad4-0096-4bc8-8d29-29623d3658c9 +8edda4dd-07fc-4457-b9c0-a28a97cdf9ee +4b7b09ae-d11d-4d54-aad2-c7dcbce92e04 +3ba8ace3-be63-4a11-b057-8ede07d49089 +70dfc341-127f-4d54-a8d4-8159eb119a8f +\N +f4910786-02d1-4874-9be7-c2cd5774fa1e +61a8407e-91f4-41f4-8050-32c8659839ac +d23c6778-d021-426b-8435-e7ee7172a456 +\N +77b3bb98-f8a6-4dc1-b2db-174da47ef88d +4ed9962e-9f7b-4bd2-b791-62c87e7e0f32 +\N +bf30fce0-2497-4594-94e2-5dabb58fa3d6 +289dcd8c-8046-4748-b1e7-3afc51e3791b +622aa432-d5e9-4d02-8a3f-09813dcc00cf +f95c69c4-7d22-41c2-89c1-6bcc6835d478 +2b4ed1c1-38e2-495c-8fba-f2060b983f8a +05905429-70b8-408b-a9b1-b8f00522ec7a +8b1dcbd2-10ca-4a37-a080-a1c846519370 +a6225a20-25c9-4afe-bc33-e6f600eb57a3 +b0121e3f-157c-4c8f-acf3-78dfc752bcb5 +\N +\N +11f510fb-ae06-4542-b936-cb5713908e10 +\N +26293032-dbd0-4914-be29-c060c5adf98b +d3d0b0ce-b60c-4864-9557-ba4a9cca8b1f +16c70611-bbfd-4a46-95fd-3c9e12ff4641 +27dc15a1-5518-4310-bb31-52da9f148afc +a86c2830-282a-4a74-8b5a-e5b562325d82 +8afadc39-3a85-490e-a31e-18d5e787a639 +1159af7d-4d72-4651-a013-9de9f3f03002 +5835b0b1-6a50-44c2-ab41-81fa34a29411 +\N +e031ab87-ccb2-496c-9eba-9966415f82d7 +\N +67b1194b-b700-440e-aa35-93f118707632 +a9a88b6a-c2f0-4de6-ab99-b34853aae425 +c9e3aeda-2001-4ab9-aaf1-57b33d841960 +6bbc3fae-1495-4178-8445-04960dd97c56 +bd7e52f5-4362-4447-9f7c-da14ed54266b +145fd346-4057-4e91-aa82-594d7a16ebce +\N +029d9c72-77e1-4951-b185-30574d00862d +d9233d92-3491-4985-a6bb-763f177535a5 +abe1ffca-8325-4041-8acd-b08904f76cb0 +0c8afca8-f720-4c4b-aab4-e061011db5ca +4f636f73-71e8-4b14-b4c5-25233d115421 +f05a62f1-f495-4ea1-9e20-433c67d2c94e +a21ee4b2-e9bd-4510-9b74-0bac543fc378 +a41bf7a6-92c2-48f1-80ef-0c3d4e002b5f +ed6b5777-b1b4-4e85-ab12-ce1f8054ced1 +04b9cc30-6d01-4f5d-9254-81eb78fbb4af +a89561d0-88e2-43d0-9548-35be00b1f028 +c77ad187-1ed9-4b25-a474-35bf8481cf25 +cc4cf4a1-aa64-4916-ae50-5fa7bb5c3b3b +\N +70337711-dd30-4454-bd6c-0e8f77ba34a0 +1ed02b49-aace-4c5b-a1cf-bc20e2edf03c +84b0f797-baa6-448f-ba29-0234e64ac30b +40556603-648c-4359-9c4c-5e76f21efd1f +af21ec76-27d6-47d8-9ede-1b08049410d3 +0f889e8a-e3b5-46bb-b222-e91cf32623ff +3f5403c1-16b1-4a36-bf4b-77333226e8e4 +5c5ebc3f-aced-4036-9b4a-59e19bd9c74c +8acec555-d518-422b-b416-19a2c5cbf825 +ab1effba-c614-4af2-9c9a-df8f6566f427 +4ae0722c-1c55-4ef1-a9aa-ddd9c43f3dd0 +77e2f0bf-cff2-4128-92da-c6d4bc656267 +2e643fa5-23db-4073-8dac-6f714f823af0 +d6624eac-e776-4e18-9d3c-d6c265a8c378 +\N +623353ca-0675-4a05-94cf-7bb62e49aece +2d29a192-0272-49fa-99ea-9b30e81f0b47 +54cf75a7-6ece-4e20-8f24-036f3daa2fa1 +8964987c-bacd-4474-83a7-2ea51ac7ff3a +87f3e366-6f70-4304-8789-e03f94adcadb +603c2f61-c91c-4f7b-9de4-ad43ea68b00a +fd036a77-ee2a-4c33-a985-709d8667c1a2 +be90eb3d-c147-447b-8ff1-2a62aba6ef3c +448ec399-4249-4daf-85f8-23ad8cc7fbdf +9788716f-1852-4b37-a2c4-f4f65d4eeef6 +bed0413b-64f7-4cf3-b2bd-765b10a31ba8 +6add9145-07d8-4d1d-bad0-57c2a914b90b +\N +caf27337-384f-4f51-92ce-76bd5dbf7317 +0f73ab51-4dc6-4cbf-b74f-faced034c866 +0b8c972d-f1e4-4150-bd9e-baee71af1ca9 +0567dd6d-0386-4002-849b-591d1512cc1e +4c783517-29df-4efa-8f40-12150943e6ab +1be634a9-77cc-4e17-8b24-817067dd2235 +ab233cca-286f-4977-ab03-0c9870b17934 +88d77def-4019-4b0d-8de5-47f3b84b4c1f +036f53a5-5270-4844-bedb-251512538a33 +\N +\N +afca4ef6-56ac-4bbe-8c44-f54858b55ab7 +8613d2fe-d9b6-4491-a70d-8de3ad41b4df +f084c252-43db-4735-bb47-eb45741cedf8 +d35f523d-4c8b-43a7-8839-2c5567ed4934 +40677618-afed-45cd-9299-ff715494d56f +7a5aa5c4-884f-460f-a9f4-a0033eb82de2 +26007d37-61cc-4386-a85e-08e56de23a2c +3753e811-da3f-4a23-92ce-1ae502c99195 +2dfb1eb2-56bf-4b0f-b2f8-3ec2dc2b0191 +551d2a52-f84a-42e4-aa2b-84f7000a3926 +\N +\N +b9cd6a67-e12b-4a0b-b935-92e267ea776f +fd4ec635-a1e5-4fcb-89a3-57bf8aa408b8 +6599e40d-a602-4a54-a24b-a694432992a2 +\N +55e65ca2-4136-4a4b-ba78-02ecb8053cf3 +c5b2bc4d-acf9-4b11-ae9a-02ecb8053cf3 +34bb5f60-3e47-445a-acbd-a5889334f4d5 +743008b5-0779-4d50-8662-1c5988335c33 +71317e40-193f-4a7f-a94a-a188847b0249 +23f14966-adfc-4460-84fa-14190d33d55f +d1bd4bba-8a17-4e8f-93d9-ed09f4719ea4 +b5964792-f607-4cbe-9759-3e459a90fe5e +c49c96e9-77ec-4b75-a3d3-00f9fa8c9ac2 +842f694a-426c-45c7-a7a9-5d750adbdacb +c48446ee-c9f6-4038-9ca2-e32f8706c36f +fd0ab627-022b-4fa5-bb9d-0ada8088c9e6 +b27dd1a0-7938-4e42-a9e7-93672a7d85a1 +\N +5ae9add1-28d5-4fd4-bf1d-f5a3ebabc31e +55e65ca2-4136-4a4b-ba78-cd3fe4678203 +25706dc9-61d1-4c67-be11-22f953132d48 +723f5921-c592-40a8-955c-7f46995b8173 +69c29563-77e3-43e6-93e4-d6ed321a294e +8d6b7ea4-d062-4fb9-a20a-d718abd9e331 +b1e945bc-2a8e-4d1c-b9e7-322b95d31b86 +4ef84213-0b39-4d86-80bb-14d2376f77cf +fd3daf86-96e0-42b7-b83a-c2781aa28e4d +ad6c141d-e257-410b-8596-77153d37b428 +40dd6844-7b56-4f39-a7cb-c00ae3870108 +883559f7-e3af-4f44-aff3-a4bd906e5f86 +98c04f9a-d3b7-4d21-9f89-43ef124d48fa +\N +55e65ca2-4136-4a4b-ba78-698a09529f02 +ee145a4b-6016-4914-b947-698a09529f02 +931473e1-2cb2-4951-9ab0-039396dc2ccb +0df573b5-3ef9-40ef-9b05-208e649965d1 +b13a6d18-33c9-4aa0-b167-88542cd5d8ba +73cbd742-37db-4497-9a30-e10279e9cb10 +63a68ba8-e223-4db7-b56f-459d25d3f873 +aa2e9b1e-e09c-4848-983e-aa4adf34938b +2d58bb19-ac14-42fe-b427-59798b8d9fcb +5d3b3f34-ce9a-4ee6-9400-c7bf7576ffa8 +41945dd7-9fb0-47af-8ee9-10e5a530da3e +\N +c3a9b409-4e0c-4426-8a3d-a87236d189bd +84da10fe-818d-4a3b-85fc-d4c169ca92bc +12a7071d-902d-4438-9c40-c2cd875b51f7 +2e7e60fb-ba46-4005-b6b5-e3630b699254 +9782a6b8-d676-45a8-8991-1c44e60764cc +6760f7e2-6b5a-4ce7-a66a-9014068fc8eb +\N +\N +2dab7131-2ba8-4def-9b28-00c0b1ed929a +9d3df737-16fd-481a-bde6-12a08a01e2f5 +d8390c84-1e90-4759-bd72-2629ca4c51f4 +0c1d5e42-5070-4e51-8076-8e8c15148f99 +9374026b-0ec3-4c44-b656-36520d322eec +\N +\N +ad0aa9a0-122c-4025-b889-70778af8e6e4 +948d0dea-5d30-45da-8867-09d2e1fbedb9 +d295f644-5f4a-4808-b966-b14e73d9fa2a +2de79a17-f91b-4310-ad74-dfa0729ff94d +\N +23eda39b-4f4f-4355-aeba-72771f922d20 +bccc111d-6f15-42c4-95c2-2c3d3329e83c +c4f864e2-f81a-4b65-bd7f-cac745bd7f32 +10447976-1ef1-4599-85fe-d837074c6ea0 +8eecc1f2-77b2-4058-811c-11efb47eb662 +98ad70bc-39b0-4b33-a104-241c6970c4c3 +15c04e8c-69d9-44b7-a177-d08c5b181045 +c6de918d-6536-47b3-b80f-80d049cfe550 +548321e5-cde7-4d74-9bb3-929244806e13 +7e046db3-d1dc-46b3-81e2-fc867ee83298 +5dd5cc44-4ad1-4658-9b4f-509c35a4976e +1aecf136-7583-4d31-980f-7fa5c4610e50 +ddb79c27-a80d-483a-9a52-c61ae2f4f93f +e7aa3080-4d09-43ae-8a2b-5b539ffef909 +aeba0aac-6b8d-4d8e-a5b8-a37359c457c6 +64b5c8e8-118b-414f-9da3-73286249243c +8b72b6d2-d3bb-4e74-a79f-577ff8767777 +dccd9254-24b4-4269-bf07-cfbbd349df54 +51cb6ab8-06c7-4280-9e0f-b2b9dcf026a3 +1f3d16eb-895f-48dd-a9e2-18eda41dacea +3ecc08b6-2b67-442c-92ef-b74af4cb4f42 +b55c7f4a-3d05-43b9-846a-23b86a73d202 +4f54dfd8-39fd-4178-bafa-97b34f131552 +d6874b48-96c0-459f-8dd1-7f7dcbc44b22 +93a213c8-6e28-4eb7-8a94-e1b18e8bebd6 +0743014a-e4a0-4eb9-a9ab-23b0d0d96782 +a7ffb6c6-4e3d-4d08-9cbc-297d8b1bc29e +45e788c4-4054-4d80-886a-e4f006936b7d +c51c64be-f130-40c1-95b9-adb39ef25385 +3af1d3cb-df6b-4d26-910d-a314a57f8550 +\N +477c1cd3-e9c9-4252-bc7c-4db57368ffc6 +b49ecde1-7413-4d6e-80c1-5df680d25617 +1f127009-eb85-4e7d-bfb1-1d804d86609b +\N +25e6a224-70a3-44dc-8faf-50feecee3480 +79094fc2-36d9-4521-bf36-0f6e0850fb6d +cb9b1ab9-96e3-4ac5-aa51-8c3c47437893 +c09d4ab8-5f03-496f-ad31-4b9e7348b9da +d5ab17e1-7017-4fbf-a30e-73a97a85a852 +\N +8c937920-7219-43fe-8436-97aca339a5e5 +b8d001a3-036c-4f15-846d-32e229d66985 +bf2cae32-9096-4ae4-b0c7-efdafdd16e0d +d916d001-fc9b-4e05-985c-b172b873c217 +\N +\N +e2c40a42-ef79-4754-a089-e254345896c3 +953fb2d0-d53a-4cc9-ad48-547263b85399 +8e2b1b14-1c56-48b9-a2b6-7868b42e6efc +\N +\N +76b7f2cb-00e9-4936-bcd0-ebf1db9c6fec +e24d88fb-6219-44c7-9f70-d34e0b274cdc +fda48ed2-113d-4403-b2dc-57f7afe25842 +9aa44ba6-6c48-418d-8689-eab1112b3fbb +42936d25-09a3-4af5-ab98-8c1216c5eca9 +\N +a9ddecb1-b762-4cda-a785-cce77c51c67a +f733a811-b83c-4a29-a59c-786825ea2070 +95e94fe5-eea0-4656-bc34-15724a4785a2 +521c55e4-3a5c-4064-b42f-0e8023af9c94 +a3379a9d-4b32-4956-a814-57b46db4bdc2 +0e46cef6-49ed-4a54-a6be-debcb7546583 +\N +1b1f4424-5c05-4ee6-8eb6-1deb677c743f +\N +caaf024d-ef32-42e5-8875-6fe563e7e18a +\N +98e9ce77-8677-44aa-8703-4633dd089225 +66037e2f-634f-4096-8823-9ded5cb533bb +\N +f6726b9f-8a0b-498e-8479-3ffa7af0cd62 +\N +4fd27a3c-2dd1-4f3d-9f48-a50407e9d1a3 +75737e5a-a509-4239-a627-99e430a4c3d1 +6a8bd5d4-7545-4dc8-86c3-003321cfd437 +73e26e64-baa7-4a9b-8833-8bd822c47146 +\N +d6de86fd-3fae-4de2-9082-e86e53b6ad7c +1143e251-091a-408f-b7b2-c12d05b42c2c +4cc745fe-4667-4041-b941-4a3a23f9c727 +ae7b16f4-9ba8-4dc0-aae7-f78258d4993b +38c5d6b2-ae34-4054-aa07-9a689afb23e1 +3421dcd4-553b-4ba6-b661-5cbf687b982a +\N +75ab9d18-5ba5-479c-b3cc-bcf3c41618b8 +c5a768bc-7765-4973-bd8b-a9528279a0a7 +e7b98405-47e6-404d-ab16-bb76fcca2b1d +\N +6b764c11-a1f1-4ae2-ab87-88bdf7597cbe +\N +e439cb96-6502-4207-a0c8-2fa6bf583bd2 +\N +0d3089c0-3e26-4425-b48a-3e8f18c8b5a2 +1a625bc4-f83b-4735-bf01-a9f748080fa5 +1d1f382c-c702-4c59-84f1-4b4e2f01d1ca +8d3b094e-112e-4535-87b3-04272426a956 +616f4879-2a33-4a5f-a776-08462d27ee1b +e2c83f19-3163-487c-8fc1-7fc00d40ca75 +dbf94f48-5f01-46dd-a13d-def8f9dbb6e0 +8c37b9f1-9766-4a5f-a222-eded294dad76 +\N +4cb9a4a8-e4bf-4757-9d68-36a3e24d7b6f +071ba528-c84a-45fc-8ac5-2368e6c640ae +ad34c9ca-0a4b-4c23-b64c-ccffa1f4dcd8 +4915fbe9-84b6-4bec-b6b4-50ff0cc49e9f +622ef77b-e22d-4ca2-850b-298abb39d870 +3e1803c7-8109-43f2-a742-b4ae6e56be55 +\N +0de0b43f-3e59-4060-a43d-baee17dd2c57 +\N +1a8e57f0-e65b-4e55-b46a-207825e00287 +\N +\N +1877c37c-3567-46e6-9afe-222ac3ccf36f +8f4bab7d-9454-4081-b1af-8e4956ab940f +c1d23aab-ce09-4afc-a95c-b9b0f7b9c16a +04761b0d-40ce-4cb2-a7e0-b1f6d582be26 +a29059f5-d4bc-446f-b903-6f09ec57a410 +4f9fcf12-54ff-442e-a7e3-6aabf45fa474 +facf76d4-e82b-44a3-9d7c-50a84395a2dc +\N +84484041-8e47-4349-91d6-418e9b584750 +44b949a1-502e-4309-af86-90bdfb04a085 +c5da9f0a-cca7-4b5b-82c2-1108e10989df +98e487b8-9527-4fcd-a20a-812c909f1342 +e950bf7c-280d-4774-8891-6cf6da8c8ab4 +d5a28af5-f357-4de9-a8e3-3518a8ca5556 +ae450238-e659-4253-90ee-afd66a676515 +294509e2-b4e1-42a3-8982-b7dca385e4c9 +9546a087-6cac-47d6-b55f-3828df9aec99 +4a715abf-18d1-4ffc-9ea3-fd3f069502d9 +e0e07aef-ce8b-4499-befa-430724707d66 +4df8c6d6-278e-4ba4-af45-7240805ce0a0 +1637abb1-1d05-4055-98fa-296fe8f8bbf2 +e3850663-b73e-4f0a-8107-0775825783ef +7b2dbbbf-2c82-49dd-9383-0edd1aee6d89 +2b99818e-2c53-4ab2-8f78-29bdbaa208b2 +22787985-d2c1-4af4-8b90-7bc441123952 +153166fb-923e-41d4-8413-edad8959a8d5 +732fab66-3055-49f8-807e-463fae914988 +1c39ccc7-2b24-4760-93d3-3e687ed04e1c +33f3d119-ff2a-4341-8145-b69f67e11192 +0370cd89-a0c1-4d8c-85fe-3df1eddc734b +d5a5e95c-e99c-48f6-9ebb-765651b893f9 +3e73a023-7b53-4323-a1f3-511809d322dc +44d2a25c-933c-4345-8d19-cc52daaa9f11 +fc25f498-455d-4a13-9ca4-9ed2b843da17 +f9737152-aa7c-47a3-b96f-d0560ccea84f +\N +c1140446-9885-4a23-a709-593c0ba3818d +050474c6-e6f5-417f-bcb8-2cc288cc412c +9f07cb2f-aec4-4108-a07a-ea51366043f2 +4d9cf071-119b-497d-88de-0d05d21bac34 +7f5de1dd-3848-4ad8-a0e6-fb4039eec4f8 +f97c4e03-e8ce-443f-846b-82485c8bf04d +2354e08c-8415-4b24-8cc2-b7b7616b6588 +b0a5e7da-9382-4a9f-b64c-0c4e5c3755ca +c4812583-5689-4384-8044-e200f796afee +890b609b-ac04-4bf3-9070-492a5db11e1c +b0789be3-59ad-44e5-b1c6-394df496ae1f +512ee0f6-380b-4758-ae20-b10d578473a9 +ad84303a-90e0-44dd-a7a2-b6015e748067 +986947bf-e924-4fb8-bdec-bd91f1b9d634 +fa576306-7eb6-411d-aa92-9e67678530ee +\N +3d66ae17-f27e-45f0-8b95-d47821b1d09c +e8f40639-2c3e-4802-96e1-b8ccf15762f1 +482c9541-9fa9-444f-8155-ceb86056f2f7 +f8dbf3c1-c67f-4a71-8bb1-b754d2fc4d9d +4764906b-3b71-4ccf-80d2-fb985af7728a +628312b0-5f3d-4856-a3b0-6e7f60dd19ee +37b5c576-d2c0-40b5-91cf-712b41dea919 +e7eefe4c-e647-40ba-bde1-bf4aa780b0ab +\N +4089198b-e1f1-4cf5-aa74-1e32aef1f034 +\N +5133a3c7-b9cd-4659-ad99-0453b433f237 +7d6c0ec0-0c7c-4a98-9d75-74a937b7ecba +74faeb7e-e0ac-4505-b2c5-bad6a39c6abb +ad895aff-3527-423b-bc82-607d9586f5fc +19a14c87-ab30-4747-8dc4-7599b4015960 +44955907-c727-4cab-aec3-464332e444fa +\N +b5d4dc6b-b65b-4a36-8f16-cf9760631718 +\N +49b4a368-b530-49ec-b8ed-7664c2dda4cc +e70020b6-eeac-425b-a3ce-9f5ad642f371 +448473ab-2a0f-4200-b7a7-b7583002779e +\N +\N +8a8b74f9-f49a-4f77-b6ab-2011df5645ca +\N +67ae0fa2-08c6-4566-92c4-adae5be3c3cc +1453d200-133e-4df3-9723-eb43bd21d896 +a7f3072e-e567-4e23-9bd0-70aba0554281 +f9caa2e9-6d43-4559-a9e7-6e5d7e7b2769 +b6a0b42b-70a3-42e0-b623-9dee8e2d3b85 +\N +05f2c97f-4c81-43a2-9c7b-8a1cf8de2474 +9287055b-ef1d-4b7f-bc28-fd637adaf530 +e0ed08d4-2521-46b1-983a-03c3cf915e42 +285a1259-f929-4e37-b25b-62af93fb1ea1 +d76631da-ace1-472c-a23d-7d4f2702f771 +80f89372-02be-4ad0-a1e5-9a2490769427 +\N +3c1043f7-f77f-4788-abc7-5615804ccd69 +a3942f4f-27f4-44bf-bf28-6ae854d4d346 +3b741249-a9bd-452b-bd08-9ae337134f13 +5aea4b8f-7dbb-4b7a-ad1b-cee1d93a5393 +cae01e8c-e75d-4c3d-8d90-ee3ebdb011d0 +13aeefb0-dbba-4cee-b108-931f23e286b1 +\N +40aee193-6c24-4a13-a004-9f4dec1ab2cf +2b731fff-597d-4a6e-888c-2ec72fe0dbef +4581b196-149e-492e-9053-5040207dcc19 +68d07598-261e-40bc-a2f5-e8f72cc86104 +94c1ecf0-2bdc-4d0f-962f-226a9617b8cb +2fcfe646-edc5-4397-8032-c4b4cd88afce +2ed39277-375a-4e9a-846d-660fe531bed2 +1244efdd-5d49-403a-9649-2550abae81f2 +281b757c-a039-4668-adf1-ff020ecf17ae +10f75609-865a-4b80-b5b2-39c67aa70c33 +8fb26a73-0535-4603-961e-217353617786 +98a14b8f-9a24-4c1d-b823-26d07b3d0e30 +200890d3-e23d-42dd-85f2-e9e4961495e6 +0faebfcf-6202-4799-b302-40c258d546c3 +714a3c57-cfdf-4db4-81f7-8bc0b9119f51 +c4f0d33b-3b8d-46b7-af89-2f5cce9d495a +\N +0a00b315-9668-493d-ab38-48d20cb5756f +a0a20648-1759-4330-94a3-e39746fdb30a +02890263-b147-4323-b59b-d533ea9d436e +ed12380e-14ff-4ec2-a47d-1b57dcd9cd68 +6d23b5ae-ca06-4aa7-a282-d96315c3ba83 +dac7a9bc-97e3-46e5-a543-ee4071ae9f0a +65995243-a887-407f-b5de-f6b25b07e3a5 +4831f146-46fe-4d57-9569-80852b0f655b +46037b99-bc54-4266-94cb-384c062346e4 +10661769-8d53-476e-9be4-440258481fdd +5ddd5380-3f03-4a76-b682-b65e1ff1a431 +5e1fe5a5-14fd-46e9-afd2-54908de1582b +62c070e4-7647-4c21-a4dd-cd8203ee6b20 +\N +efd4c5c8-629d-41be-8982-e3b8352f96e2 +16a2c85a-f455-45bc-8a29-38f7f664fc7c +0360c257-6ea8-4d6e-834f-43f37a7d8f4e +e2562225-53fe-457e-b538-c089d3946aec +ddbaebbe-8294-4f8d-8452-4a46d1b43c53 +dca63b45-648f-4b4c-a36a-c53f3e0abe28 +04e91983-21f7-408b-b4eb-aa6d9359f37a +905c498a-4b99-49af-89cd-fd1d022193e7 +413d7f85-6bdd-4d50-8859-afd317c841c4 +412ca3ee-90e5-46ae-adf3-80aa6ceee633 +1a8020e7-8671-46e4-b2d3-705e206723bf +9414f47f-088c-4fb1-98f2-bc020b0d550b +8f48e9ef-ae2c-4d0a-acc6-8d4b18622df5 +614cbf04-fb3b-4678-834b-da05f70bd529 +0c96ce68-9135-4199-a351-05f9dfc641e2 +f3dfa1a0-c156-435e-9f2c-662c345b92db +\N +d7c6b8cc-2d67-41c6-bae0-3ab23f8ad65c +b8ae6503-dbed-4455-85ce-6b985b4338ff +3ba1530c-911b-463d-aa61-5d81850b5fcb +\N +0f71da52-80da-4bc5-88f7-013603f8ef06 +f59318ec-1851-4beb-b02e-6e9ca7f2391a +8b712321-af06-4af2-8654-1e174851ae59 +\N +\N +c30e01ed-17eb-495d-8381-dc87cd280002 +10537620-20b9-4706-a1fb-ec470349e4d8 +bc669e4a-bef3-4635-a3c6-47e70a307e70 +5d965491-8d0d-4f7b-bab4-b615dd97dbcd +fa76b0d2-1c46-4855-9381-3ec02b21b475 +311c71c5-e5e2-4224-aa57-fc79adb0d037 +82f18b3d-dd3c-402c-a54b-afe92a8b4582 +8a39cdbf-39c5-41a9-a4cb-c334cccc0414 +396ed0f3-8c28-40a8-a5d0-b41d2448c618 +4dc37b03-f161-4436-bb41-3e114f78bb96 +1de1ff4c-5b47-40d2-a002-ff331900c4ec +7b248f50-920b-45f3-b20b-19d75590ef3d +\N +eba46805-9b82-4ebd-84d2-5aa6cb3d8a48 +2fef1c4c-d97c-423f-923d-cbac15961fc5 +7ae4af7a-3759-4ecb-9d3f-ed5e124ab08c +f812e63b-20a4-4f58-90be-e6c7357d89fd +cd91b9fe-5daa-4087-94a7-459c54d24d39 +54f4f7a3-c581-4bff-9bc1-82d8aaec2d3c +\N +d900a862-a0b2-4776-b418-af075881c53d +593143fa-99b6-464b-b563-33e201668db0 +1d8ffc5d-1011-41d5-b3bc-18e0fe5b7375 +93773b54-be94-4b99-9bcc-e181f1b09978 +\N +7fe6a809-a67e-46ef-b686-4a982a6f6fc1 +00c65908-2e09-4974-8c61-37ec926e74fc +d6f2cc12-6d93-4159-b247-70db9120217b +29806fd9-24bb-4e50-a228-8ad6c17559ab +bd093e48-01be-4a09-a8f0-33a2bfcf23a7 +13d3db20-68e0-4cb2-8530-90648e6a756c +b5bb9551-bb70-4589-a12c-15350d85232b +6736895a-671b-435c-85b7-133c65b09cc8 +a609184a-9035-4b75-b10e-838465bace14 +98c084a0-9c30-4dc0-b8a2-2b818f650034 +122afe72-60e5-497a-92f7-c8139339f999 +6b2b6d77-f49c-4b37-a57f-c8ab6f8deff3 +6e133f18-5a70-4717-a750-1c2ee9ab459a +\N +\N +96e2dc30-cc7e-4c9e-bbbc-e4af1ce9b5f6 +0a430277-f67d-44df-88e6-3ae2e78b8a1e +15445ff0-2087-4fa6-857e-baba197a3ec9 +5a8aba7a-1feb-4acc-b57d-2520233ec15f +a17ef384-5204-4240-a493-7db5dc28a6b2 +bfa0fd7d-7d18-4c57-a066-c94be05d0730 +4de53a8d-d76e-446e-9b68-48618314f2c4 +21cb20a2-36ab-4756-8925-cf8bade61148 +a2376936-9836-4397-a3eb-e779e498ab2d +f4b3d211-79bb-4256-a460-26dac56d9755 +4c4be10f-5141-429a-9ea6-24eb1fbd5330 +a45bb987-b935-44ae-a410-c82b1f895eb5 +b341e29a-e069-4ba2-b2ba-279b53c1fcda +68a4e4f8-9d7b-48f0-8614-e2a2072c859e +dc20e7f1-b79d-4135-b90c-cd87a265169a +1c5bfa73-8814-4f5d-9718-a12417814c41 +3000c028-3656-4455-b095-0b9f5ab1dc9e +\N +3d13811e-7b7a-4779-ab87-5257a1c702d1 +a9ea4067-e53c-484c-87ae-bdb218fbec40 +9c3925cc-4dba-4dd4-8000-c646f45db751 +f2e7334b-9840-4e9c-aff4-d7ac58ecbd91 +889d6968-a515-4458-a353-4a3d8d7528bd +dc02f6d6-fec3-4c2f-ace2-6a124a61f079 +9f48ed94-313c-4607-9c23-d3a1b20eaca4 +\N +\N +2428f056-4dc2-4db1-a110-20bb54a3037a +3cc8dd23-fd3a-4855-8ffa-23d1efa4fdbc +bd3e2f1d-5869-42ff-b1c5-3f65ae2d1974 +\N +\N +8330c73d-0dc5-4caa-be02-10e136137804 +f202e559-6ab2-4b72-a6e3-1bf16cfe8bf5 +54e42957-25fa-46c7-a939-eaaa4b54a5b4 +\N +7c3b2d81-44ca-49d1-8b08-c33f691c4f3c +\N +5083bb0b-7fa7-4ee1-8e51-ce20ee53a16c +ffdd64de-2c27-4858-8baf-b179f0fa690c +6e4632ce-f908-4c13-a15a-ac5cdca38c76 +e428a015-0cca-4b09-bb5c-ee4bffbd2de7 +\N +\N +d7a270ce-7ac4-49bf-a531-e56960f56850 +80b82b49-3984-4b6f-8690-7578f992d987 +824d6c6a-273d-4bfe-8ca6-197c8477d6c1 +\N +\N +5dddc93c-c4c9-44fc-8916-a826089245a4 +21357386-e17f-457e-93b4-77295904e67f +f9598cd5-3c4c-457c-b6d8-11049bbc94b1 +05f7fbbb-1660-42da-a154-de4aa6cce4df +a3b6aeef-e8b5-4692-944f-eb5edfd6a0b5 +cb8f1dea-fefa-470f-9a9c-1e169df844ec +\N +4b12759f-10e0-478c-b2d4-7c71be9f837e +3688c161-bc5a-40a4-a9a9-6854b623a139 +\N +a6a6ac8a-b805-4f15-bc8e-71c3679221e2 +ddcdad12-0919-4b8b-acc8-e775aaf6b6a1 +0dcce500-a4d6-4d34-916b-686cc04ceaa9 +2190bba9-e7e6-413a-85e3-40735e791c1b +3f06e070-1530-47a7-8898-a94d82ea59b8 +bfb7ef50-9a5c-4341-a65d-c7b9ccb76d39 +70972a38-8f23-478c-abfd-9dbdca17dd01 +3c6ba50f-9197-4f0b-bf46-ca51aef246d1 +fb4598bf-ffa0-470e-b8eb-2d704fc08bd5 +fb2bd46e-6f43-4b2a-a122-dd6539ccc03c +49f8d0a6-b7b0-444b-90dd-1cb5d08e95e5 +\N +e8b02af9-8671-49d3-a1bf-86e222fe4ecc +\N +26c6af97-9ffc-43bd-a926-da45469c3c52 +773ec08a-9d02-4a8f-87e9-f4460d703952 +286f3446-6e5c-4b91-bb47-d6106346369f +\N +2e1c1f21-8cdb-4a33-96b2-85b3eec11e41 +d7b3ebc0-62a0-419a-a710-f9950d012f92 +3edde810-79fd-4f1f-aa10-4aa472d9384a +a13013f8-e1cf-4902-9c95-8177d8a220a9 +b7c226d3-d115-4bf8-b03c-e7f14eee2169 +91a75836-a7a6-488b-806a-e8f948c8eb46 +b30da379-97b3-4a94-b6a2-2064767d2e52 +befec357-cf20-4712-9805-34910608e2fd +ca95130e-1c44-4733-a872-c0ce24d1b3c1 +\N +f5001512-9140-43c9-a4c8-54e26f71f1cf +a3f2283e-50dd-40b9-83f3-b50dca485209 +3f7ac41e-bc09-4b74-8665-bdde3ebe47a7 +761e1883-d06e-4360-9df5-5c5caeef905c +98cffbaf-dc52-4674-ade0-f930a70b64b2 +370e189c-b821-41ae-b748-a60b6d7660eb +12563667-28cd-478d-b53c-442f7bf12c67 +\N +29fe6754-ba91-49b4-bfb7-12b3dc03081c +87aa5cc1-3332-4bf3-a669-5bb61e56a7ee +\N +8bcd3587-03fd-44a0-aab8-b8aca2bc9eb9 +9ae7c0f8-6038-48af-b01f-0c5bccac6c8f +\N +3e98dbdb-b10f-4f6d-a87a-c8f1f2b1e22a +cd53b5ef-38fa-4d68-a8ff-4eb07f4162b5 +514644a8-fe52-4bab-8bb8-4cb8c7ef7acc +\N +b01b6978-46f9-46ec-844d-1322be2cfcb2 +04675ff9-2d55-413d-a3d0-4ac0ff1d3a54 +a7ee0137-c56a-472c-b4cb-dc41f1177ef0 +bc41bfcd-e5f0-423d-82f7-ffb7da97b5dd +55824064-db88-4077-ad90-945d878e88ba +a30050dd-1a17-4659-b3a6-c4c182ff0184 +82ffa955-b664-4503-9b1c-095404dbff48 +91d67d53-ec53-4dae-95ca-da25c1cfae7d +da144505-c151-42a4-b8d5-19ff810ae6ea +cfa1ddf5-6149-4896-940e-5dc57e4ec766 +c3a56789-f97f-4d5a-b70a-7d24da43bc5f +4547a150-68f8-4984-b7b4-67ee92315b6a +6b6d5e01-b18d-4afd-8b6e-8c3af536efe4 +bf723c93-f506-4990-9e97-b65476044b30 +c3ec8969-1f70-4b19-977b-237ede99a6a5 +78f11bd7-7a10-42ae-9475-eb16ca80f1e0 +cb3bf2fe-2d6c-47e7-b1e7-ce3254d2f800 +3842e996-3d91-4cab-8cce-da007a08328b +4c55e078-603b-4d4e-9c77-c747960f6aff +16d9f806-448d-48a1-9473-4d30df05aab8 +4611148b-cf71-40e6-829f-95ae0f2c8094 +9f3bcfbc-24ea-4105-8cb8-37a0924ff5e2 +4fac2eaa-2bd1-4d9c-bd80-a7ae083efcf9 +dc5546ca-99fc-4c1d-9559-b2ed9cd3d2aa +29721775-9930-4f6c-af20-bb5b5f8d0d73 +f39a6eac-e7d5-4124-9a65-9508bfc53920 +\N +7bc9960c-cf4f-4cca-a752-b28c5805ae01 +0e1c03e3-2cca-4bc8-b160-d6c2e888c182 +b12bb0d6-45d3-4608-9992-be9804a09448 +31bc67c6-1293-47c0-9732-5094e0b996bc +a262ce01-cdf9-47f4-8f48-e94d4b9d73ce +bc7150a9-0593-444c-b7b7-cc142348f1b4 +2f1e9e36-7e1b-49a5-a83e-b330267b5051 +f919c11a-b74f-4543-9798-da31133f90b5 +8672777e-a462-4042-9604-4392bbbd3308 +37b53421-3c74-40f5-9884-b83033e9f596 +1f843010-c79a-4bd4-a0a5-0251e0389722 +c51ecb09-45b4-40ff-9934-877c168c5038 +131335ce-a059-49c4-81ae-c9d98211ff9c +f467b40d-0c6e-40b9-9959-2f7f466f18e2 +44076ea8-1103-4086-9e7d-8bfb9a65893d +79ca8799-36a4-4982-9cd7-bf93fca45d74 +82569d43-65a3-44d7-8836-2db6de03e6f7 +cb5380e0-b075-48e6-8a9a-eee854444d34 +db88f31c-ce62-43f3-9781-8a8404e6ba39 +78f33ab0-a744-4bf1-82a7-c0b319492607 +2e4b580e-7d69-42c8-9f1d-7f232a3ae74c +427b3d53-2792-47d3-9d45-087b30568413 +40518971-9590-45fb-9219-242ab3053547 +fe49087f-d8c1-4769-b814-fd8bc1611b5c +27f8a8ab-671e-4eb2-88b4-2ad41814df1c +39ebe842-6c44-4fb1-a629-3f86323ca5ea +4a341b56-3523-4163-8563-83b9db172673 +513dd3a8-7354-47e7-9eef-d2a9e59a0e18 +b8e38294-7be9-4c39-b80f-bf2c9acfe69f +e1fa23c2-b0b6-47b3-82c9-eef6e930af08 +1b86903e-c395-42c7-b9ad-1a71a1fb52d1 +632161a2-474e-450c-9b70-0f09f512bcba +73f00c2b-ea38-46bb-aae3-4cf205572baf +013839fd-03de-4fe5-a08c-466670de6cbd +5d951cfe-d988-4b69-bce8-37d66598cbc3 +4da7e8f1-edaf-404a-bd1b-e8dd3a838fe2 +1f2c1809-8b85-48e8-ada4-1fdb418fea0e +\N +1bde5bbb-5d63-4d00-b227-1a706315eaa1 +f7ebf8f8-609f-4ce9-b93c-54759305926e +\N +7c2dd991-9377-4001-8486-7f3c3a6bae9c +9fe1e97c-718b-4cf2-b270-4e0b664aaf27 +2141a8f5-da01-47cc-8104-6dd28874d8ac +304096e8-b118-41e0-8174-32dc8e1fc45d +9d5fac3d-e6f2-4341-9e59-9a155bef7b17 +b42cebe1-f01f-4409-bfc2-150aa9f13159 +91adc8a2-266c-4196-99ff-1de1c361c3ef +54d26aee-0309-4af7-9b12-bbb24eb3e4e1 +bd449351-c50a-43b2-9742-1bcb838d4d04 +9fe70798-e3bd-448a-b461-e462702a9aca +\N +c8ef8969-1332-481b-909a-340ff3fd4473 +64c68c64-f815-4bd7-b0aa-ba68bb15f611 +9f271158-ff4e-41a6-a883-913f2b36ae68 +\N +b1082d66-0065-41ac-9bc5-dcea0bbec070 +\N +3ac2d674-2e12-4db1-b998-2470cba43b11 +\N +3061f573-96e9-4307-a683-df8ab30531a5 +01ce8c0e-7672-4023-be71-5dfae5ffa7d2 +06a9e327-29ea-4913-b6b9-90781484eff4 +9735f9eb-89b3-4f42-bfb5-e2bb208b640a +21ef890c-1c8c-4890-8c6d-851eebe68f40 +c35686c4-cfcc-48ff-b6d9-7c8da68dceb1 +3f08e734-1f52-42b5-ba89-738582a7f5b4 +12975217-8a58-4a95-9ede-4ceb0a487a67 +97e186f8-28a7-4340-b781-cd13168daf99 +2336ce4b-3d57-46f4-b460-cdeb89c81fcd +e824b114-66e0-441f-aa94-27feb7a3f672 +b8bf5230-0174-4f16-9470-dd476b9675d6 diff --git a/contrib/btree_gist/data/varbit.data b/contrib/btree_gist/data/varbit.data new file mode 100644 index 0000000..b25a264 --- /dev/null +++ b/contrib/btree_gist/data/varbit.data @@ -0,0 +1,621 @@ +10101001001110001110101100110110000000110011010000101000100010001000011110000111100110111111111 +001110101100110 +010000011101100110001001111111101110011110110100011001101011110010101100111011011101101101 +1111000010000011110011101001101101011110101111011011001000000101111110000000111011010100011001 +1111110111111000000100000101010010011101111100010100010101101101110010111110110010110000000000 +000000110100001010001011101110111110100111010011000101111111000100001001000011001011000111101 +0100001010001011101110111110100111010011000101111111000100001001000011001011000 +011000001000011110010000111001110101000110000011000000011100010111000111001010111110 +1010100011001111110111111000000100000101010010 +01001110100110001011111110001000010010000110010110001111 +1011000111101100000110100000010101010111101100000100001 +01011011001100110100000011000101000100010100100000110100011110010001010000011 +0111101100000100001111001000011100111010100011000 +1101101110010111110110010110000000 +11010111101011110110110 +01000001111001110100 +01101101011110101111 +1111100110010111101111110101010110000010001111000000110010101010011100100011011000001101011 +1010000111011010111001111111110000001011010011110101101100100000010111010111 +101011011100000010111000010011011100000 +011111000000001101111010000111011001100001110101001110 +11 +\N +0010101010011100100011011000001101011010110001101010110010110101001000000 +0101111101011011001100110100000011000 +110111 +1001111001010101110101000100110110110011000111000011011110101010001110011000100011101 +110000001011010011110101101100100000010111010111101100 +0001010100101110001001000010001101010010001101001001010111100011101101100001100000011 +101000000101010101111 +00011101001010111110100000101011000110100101100001111010111110110001000111101100011011111000000 +1001001111001011100001010100101110001001000010001101010010001101001001010111 +1100011101101100001100000011110111110100011000110100010101111111011011011010 +0010101110100110001001001011011111111111101011 +0100111010011000 +1111101000110111011011111101001010011111001000110011101010000100101110110101010010101001001 +11110 +00011011100110110001000000010101111111111011101111010 +011011110100001110110011000011 +01111010111110110001000111101100011011111000000101100001100000001101000001 +111101111111100111111011000110000100111100101010111010 +001 +1110100111010 +01001101001111101001000000000000100100101010110001111101111100 +\N +\N +0001100101101111000100000000101000110100000100101001001010000100000001000001011010 +10110110111110100001010011000001010110001101000011101010001101101100111100010011000111101111001 +11010101101110101001110010111111010101101000100000011110 +101001000000000000100100101010110001111101111100111000111 +000011001101101011110101000110001101011000 +01100001111100011100000110001100101111100100111101100010101101101111101000010100110000 +01011111110110010010010000000000110111000010011011111000001100100001010001100100010101010111110110 +111110101010000111111111110000010001110001010000011110001110011001111010101111000 +00011000001000101111000000001000010000011100011010100100101100011110101 +010101111011 +11111110111000010111101110101011100 +1110011001101011010000100010101110110111000110100010000011010101011101001011000011010111101010101 +0000001111011010011010110010100001000010011010011110111011101100000101110011111 +00101001000011010110100100010111000101011100110000110111100001010010011 +100101000010000000100000101101010100000110000010001011110000000 +010110001000110010110111001101011111110000101100110010000010011001011111101100010110101011001 +01011110001110101110000011100011111111011111010000 +110101100001100110110101111010100 +010000010100111010111010000100000110011100011110110011 +1001100101111110110001011010101100110110101100100100000100101101110001001101111001101010 +010101110011001010110100000111 +\N +0100011010101110110000010011 +011101111101000110111011011111101001010011111001 +10010100110110011011001111110001001000110111101011101011010110001001001111110 +1110111110011100011111101010110001101110 +01010101110101000100110110110011 +10101110100 +001110100000100101000001010011110101110111011000100000 +100000111010111111110011000100100000111100000010100100011011101001110100001000100011 +101101000001001010011100001111000110000100100011100001000111111011110010110010111101 +11111011111001001110111111101 +1111111011100001001100100001110100011010110000000001001010101001001111101000011110011000000101111000 +001111000110000100100011100001000111111011110010110010111101001100010101110001110 +011000001000101111000000001000010000011100011010 +110010100001000010011010011110111011101100000101110011111 +000011101101110001 +01111001100111010000100100110101 +000001010001100010010010001001000101111000011111 +1001001011011111111 +01100111000110001010010000100101011101010 +11001011111111011111111111111011100001001100100001110100011010110000000001001010101001001 +1101111010111100011 +\N +00101011000110100001110101000110110110011110001001 +001001101110000010100011110011110101111101110100000101111111101011101100111010101011111010 +010101111001101011011111011111000101110101000110010010010010111010001100011001011011100110011000001 +0000011100 +00110010110111010100111111011111111111101100110001000001101111010000100011101110101100010101 +110100110010001011000010010101100010001100101101110011010111 +000111000111111110111110100000010 +0000001011010011 +00100101000001010011110101110111011000100 +\N +001000110110000011 +1101100110110010 +001101011101001100010101 +0001001000101111000011111110011100110011 +10101010101000100101101001111011101000010001101 +000001011001100010011110010011101010001011000110110001000101110110001100001001110101 +10011000011101010001010111101001100011100100001100011100001011110011 +110111110100001010011000001010110001101000 +000110000010001011110000000010000100 +0100000100101100101000101100010000010011110111001100000000000111 +000000111001010001001111101110011011011110011111100011101001001010010011100011111100100010 +001000011111011010000110110111101010000011111100010000110111111110 +001 +000011110001101001110111110101101101111110111110001001001100011011010101010100101101101011 +00011010101100111110001110011001011111111010111010110011101111000100101010 +1011011001001000110010100000111001000111010101 +00110100000010111010100110001101100011001110101011101110111111010000000100010100010110111011 +1101000001010111110110111001011111010000110000110010101111101010100001001000110 +101111000010100010100010000000010110011000001100011010101001011011110110110000110 +00100100001101100011101111110011101110000001001111 +010011010001000001110011101100001111011011110101111 +\N +\N +1001010010011100011111100100010100100110011110111111100101110110101111100011111111 +001111110000001100111011001010010100000000110110001110100100010110000010011011110100011011 +11110110011100011000101001000 +00101001110110111111101011100110110011110110000101100010100110 +011111010101001011000011111000000000101101100101101111100011110011 +10101000110001000001110101111111100110001001000001 +0010100100011010011100100011111110001101010000011101110100101101011 +111111001111110110 +1111110101010011101000111 +001011001111101010000011001101110001011011000011100 +0000001111010111000100111000111010010001100010010101001101101110010101001101000001 +011 +00000010110010 +000000111111110101010011 +101 +0100 +001101101100111100010011000111101 +111000010100111101010111010111010011000010001001100010001110001000000111000010101111010011101110 +000101100110010110101100001000100000000011010101100111110001 +10001000111011001101000110000101100011000000 +11101010000011001101110001011011000011100001101 +\N +0000001101011110001010101010101000 +11010011110100101011110110101110001101011101110010110001000010010011011010011 +1010010100000000110110001110100100010110000010011011110100011011010011110100 +10110011110110000101100010100110110111011110110010110 +1001111001010101 +100011000010110001100000001100001110111100 +\N +001000001110110111111100011000011011010101 +001100101 +000101001100010101100011000101111011110000101000101000100000000 +0000110010101111101010100001001000110101000110110101101000010 +1011000011010111101010101011011100000 +1110100101010010100101100101101111110111000110101100 +001001011000000000000101011100110111000 +0101111111000010110011001000001001100 +01001110110000111111011100011001101001010100000100011101110010101010011001010100 +0001100011111110100101100111110010000111110110 +111000100000000101000110 +01011010101101110011001100100110100010010100011010000111101000000 +001111010100000010101101100010001111100100 +11111110011111111010101011000101111111100110010110111 +01101010001000111111010 +00001110111100010000011101101111111000 +0011101000101011100011100000 +11000111111111011010100110011100110011100 +10100010 +101010001101101100111100010 +1001001011 +\N +11000110 +01100001110000011110001101001110111110101101101111110111110 +0101000110010011001110110111100010101011001101000000001111110111111111100101100001100110101 +1111000 +100011001011011100110101111111000 +0011 +0001000001011010101000 +10001110100100010110000010011011110100011011010011110100101011 +111000001110001111 +11001100011101001110010110100111000101011000000001111010010001 +1111100011110011000111101111110011000000010011 +010010001101111010111010110101 +10100000110111100000010 +10010111110001010001110001001001111000001100010011001101110010111000101000001001000 +1011110100101001100011111011100100011011010010011110000001010110 +\N +000111 +0011000010100110001011000000001110110111110001101100010110100101001101100100001100001101110 +1010110001 +10110 +110011000001111110101011101100111110011111111111101001010110101000101100011001010111111000 +100000100001101011011111011000001011111000000001000011100110100010101 +111001011001011000010100010010101010110110101101110000000101110 +100111001010100011011101110100110101011111000000111011011010010011111110011001000110000010011110 +1011111000010111111010100100101010000101101110011110001000000110000001111010001100000111101100000110 +0011001010111111000100010101001001100110010100101001011011100010000011110110101000000001 +01110 +11111011011110001000111100101111001 +0010011110010010111001100101111011110001101011011011011010010000 +101101101111110111110001001001100011011010101010100 +001100111000111101 +1001010001001111101110011011011110011111100011101 +11000111111100110000110101100101100 +0001101101010100011100100100001 +000111100000110110101111001101110101100001000101111001101000011010 +1110001010010000001001110011101101110101011110000100000110110111111010000101110000001001100111100 +0010000010110001011001001011110101110100101011001111011100110000101111011110100 +00111001001111101011101111001011110100001101100011101001100010110001100 +110101101100100001011000111001011011011010100100011101110000001011010110011011011010111110 +110000111100101111010010100110001100001010011000101100000000111011011111000110110 +000001011111000111100101001001010111000101010101100001101101100010101000101011110111111 +00100010100100110011110111111100101110110101111 +1011110011001 +10000101110100100101011010100001010010010011100000001100011000000100100101101101100 +1011111110011011011001100001110010011111100111101000100011010010000111100000001101001010 +110011011011100000100110000011010000111101100110001100101011 +100000110101101111000011100000001110010001100111110101101011011000010000111001101011110011 +10100001010110100100111000001111001110011011101110 +110100100101 +0010100110100010000011100111 +10101010010100000111010101000001111101000101101 +001000001010001111110011000011010000 +0100111110100 +11111111011111111111111011100001001 +00101010000011010111111011000011000101011100001101011111111111001001110100000000 +110111101011111000111010110100000 +011001 +11101111111011111011110010011100100101111101101110011111001101001001110 +01100010010101010110111000110111100000000110011101010011100001001001000010001100111110100100010010010 +\N +101011101111100101010000000000010100101000111110110001111000011001000001111000100011111111011 +0010010110 +11111110101111010100000000000110000001000010011001 +010110000000011110100100010000110000001101100111 +001000000111000010101111010011101110100100110011101010101 +0111110011110011100001100010010011010111000110111100011101000 +110001111010011000111111100110 +111101010101011101 +1001 +10011110111110011001100011101001000101101 +0100001001100111011110101111100 +011010011100110100110011011110111100110111011011110101110110011000011111000010101011111001100111000 +000011001110001 +0001000010000111000111111000111111001000110010111011001001 +111100101111111000101101001001001000001111101111010 +00010000111001010011001111100111101010011010100 +001111111010100111100010000 +0011000111011111101001001100111010001101100101010101011111110101001 +010110111001100110010011010001001010001101 +1010001110 +001011110010110110010100100101000000001010000010101110010010111111110001101011110000000001101 +010010001100111110010000010011011110101011110101001111000000011100111 +110001 +10011110111111001100110100010110100100101000100100100111101000100101011101101111 +0100111000010010010000100011001111101001000100100101100101111010000110011110100011100101000 +01101100011100 +011001111000100110 +0001010011000101011000110001011110111 +10011010100010011100110011101110000010001100011011100101101010010011001000 +100111001000111111100011010100000 +01011110000111101011011000110110111100111100001001100 +101001011110010110100100100010110100101100011100110010101000111110110010001001111001011101010001 +00000101011011000100011111 +1110010000100001111101101 +111100011001010001110 +011011100011011110000000011001110101001110000100100100001000110011111010010001001001011 +0001101111000000 +011010000101011111010010101001 +010000101001001001110000000110001100000010010010110110110001111101 +0001111110110010110111000000111101010000110011011010100101101101110000001100111001101110000101000 +0000011101110010010101 +1001100001111100001010101111100110011100000001011100100000111111001110011011100001111101 +1101001100010100111010100011011000110111101011011110 +\N +0110100101010000010001110111001010101001100101 +10010101011010011101011010011100010100001011010010111011110111001100011010110101010110110 +00100010110011010101011001 +111000100001001000010010000101011101010000011100110110111011011101100111010101010001110110100 +1100000111101100000110000011010110111100001110000000111001000110011111 +011110101 +11000110001011100010100100000010011100111011011101010111100001000001101 +0110110100101001001000001000011001100000101010101010000111100011010001101101000 +11101001100000010100101111101110000101001111010 +01100101100100001001100111101111000010100000001010001001001111011100010111010010001100 +1010001000011000110011011000111111110001101010100110101011100100001001010011000001000101 +10101011101011110010000110110101100110011111101 +11000001111011000001100000110101101111000011100000001110010001100111 +1111000100000111011011 +001101100111111110000011011101111011011 +00101 +100100110000000110010010000001010111100011100001110000010000110000011111111011010101010010111101 +0111010111101110010101101011011000001000000100001000000010110011000010100010111111110000001110 +010011011111000001 +01011001100100000100 +11111011110101001101000110011101110111101010110111010101100001101011110101011011100101001000100101101 +101000010100000000011000010000101001111001110100100001001100010010101010110111 +1100011110010101010100111111011000100100100110101001100100110011110100001110011 +1001100110011101110000011101110100000010001 +000001110100010011101100000001001111110101110000101100100010000101110011101011101 +0010000010011011110101011110101001111000000011100111001101 +00 +1110011100 +11010110001010101111101001010 +111000000010010101001111111111001011000110011010010111010000 +10010110001000101110111110111001001101001001011010010110101001001111011 +100010100010000110001100000110110011011101001101000101000110010001111010 +01010001100001111011000001001111100100000100001101110001101010101011010110000001100111100111 +00010010110111110100101001010100011011010100111010011100001101011100101000100000010110101100100010100 +10010010000000000 +011110101001101000110011101110111101010110111010101100001101011110101011011100101001000100101101 +111100011001010001 +11101111010111101101000001101100111111101110 +01101110101000001111001010111001011110001000011111011000101011001011010000101001100001111101 +10011 +01100011011011110011110000100110001011100001 +10111010000100011011111011100010011101111001000 +00100111001011111001110110110000000110111010111001010010111011011111000 +0001011111011010000001010011000001111011011010110010 +10000101110110001001010001110110000010000000010000101110110111011010001010 +010110110010000100001110011010111101101011001100010101 +111010011111011111111100001110010100110101111010 +011101010100111010001110000110100010011101010011000111000010000001011101100101001000001000 +1100110101000101010011000010101011111010011111011000100000001 +0100100011101110000001011010110011011011010111110001110100 +1000110101100111110111101 +001111001010011010101101110011101111010111 +011101010100000100101010101111010000100010010110001000101110111110 +011011001001001010011001100100100011001100001011100111101000101010001101000110001010111 +100000001100011000000100100101101101100011111010110111 +10010111011 +101111000000001 +001000100010111110011011011100000100110 +1110111111101000111011011100001 +110010011110111011011110101100111100011 +110110110001100110011110001111111011000001110100010011101100000001001111 +110100011010001001 +11010101101000011011001110100010101010000110010010110 +010110001001000110100100000000100011110011011111101000010111001110000101010000 +0100000111001101101110110111011001110101010100011101101001010111001000100001 +\N +000001111000100011111111011111010001101110100111110001011010111 +000110000110111000100110101101011111001111 +01001101011001 +0011111110101010001000000101110010001000000110100000110010100100010100111001100111000 +00111000111111001000101001001 +10000110 +111111100000000100100100001100 +10000110011010000000000010100011110101101010011110001110100100110000000110010010 +1001001011000111111011101000 +111100011111010111101101101100011001100111100011111110110000011101000 +1010101111000 +011111 +011010000011011001111111011101111010011 +101011001111110101010011000001100111011000001110000011000101101101000001110000011110001010 +01011101110010010100111000101000100001100011000001101100110111 +0110000110011011110000010111110100111001010100011011 +000101000111101011010100111100011101001001100000001100100100000010101111000111 +1101011100001101001010110111000011100011101 +0001010110001 +110010001111111000110101 +100000 +\N +10110111001100110010011010001 +001111111001011001100101000010011011001000111111011001011011100000011110 +00000011100110000110000001010110111011101 +1011100111101000000111000 +01100010011101010111010111011111001011010001101110000011111000101100001000101011110000100100110 +001000111011101011000101 +10100001011111111001101000000100100100001000100011001100001100110001100000100100011100111110100 +100111 +00110010101000111110110010001001111001011101010001001011001111101011 +1000111010110111111101000001010110110000010 +11111010111010110011101 +0100100001000001010000001000010 +101101011000100 +0001111010111111100000010111100100100101111000010000111 +1001011100100110010000010101101010100101000100100011100 +1101010000011101 +110000010000011110011110001011010111100001001001 +111101001101011111010110110000 +010111010010110101101000101011110100000011100000011101101110 +01111110111111111111011 +0001011010101100001101101111000 +0101010 +001110010000001010111001101101110101111101111001010101111101110010111 +101111010 +000001010100110010110000011110000011010110100001011101010110111011101101010111010011100011010000 +011100111110011010010011101100000110110110 +0011011010111010110111001101000000110111100000010111000010101100101110001001001101001100100110000100 +1001100000110111110100100100011000000001111100011001111110001111110010100 +10010001100101 +0011101110111101010110111010101100001101011110101011011100101001000100101101 +011100011000001101111010001000000111011100111111000010010100100101 +11 +111000010010101101101001000010001000110001010111010000000111010101001110101 +1000000100100110001101111001011100000111010010000001010100101110000010011101100111 +01111000 +0011011110100011011010011110 +10001011101010001000010001011001011101100101011001100100111011101000000011101100100111100 +001001100100100000001011100111001001000001110001110011110110110010010011101 +1001101000111011110101110101001001000101000000010101011110111110 +010 +1100110101000101010011000010101011111010011111011 +00011101011110110100100010110011110010000010111001111010000110010110000000 +100001111010111111100000010111100100100101111000010 +\N +10000111011101100011111010011011110010000100010100000111100001011010010001001100010110001001111 +10110101011100101111011101001111011111011011101001110000010111100001110110111001011010111111111 +1101110110110000011100010000000001101000101001111010 +1010010101100110010000001010101000111010111101101001000101100111100100000 +011011101101110110011101010101000111011010010101110010001000011 +1111001011100000111010010000001010100101110000010011101100111000010001101100010 +10 +0100010100111011010110110000100010110111000101101011101111101010101011010 +0111110001010001110001001001111000001 +1101000101101001001010001001001001111010001001010 +0111111101000100000111001001101111000011010100101010010101110110111100011 +110110100010010110010010011110001010100111110000101100011110110011011111101110011111111 +1010011101110010101000111100100011101100001110000 +0111110000000000000100110110011010011011110110001 +001011110101110100101011001111011100110 +0011110010110111001010011111001111110001 +1000110010111001101000111100111111001000000000111111010001001011010011011 +111010100111101111110011001101000101101001001010 +1001100100101011001001110001011010001111011011111111100100110011010101011000 +1001111111111001011000110011010010111010000 +0010100011110100011110101111001110001101101100011000000100100110001101111001 +\N +00100111100101110101000100101100111110101111010011011111100 +0101101011001011010001100111101110100011101011110101000001011010100100010011001111001111 +10001110100111110101001001010111101011111110 +1100110100000010111010100 +01 +1100010010 +1010001110011001101000111001001101001111101000101110110011100001000100111110110111001000001111101001 +000110000111001111110000010010001100001010111110100111011 +1100100111100111010010110001111111101001001011100111010000101010000011110011100100111101100 +10111000000010111000111010000100111110000110100010111001011010111001011010100001001101101000 +11010100110100011001110111011110101011011101010110000110101111010101 +0001110 +0001010001111010010110111111101011110011110010010111110011001011000111001101101011101000100110 +11000001110001111100001110100110101111010000101011100000001000000000100011001001100011001011 +01101111010100000 +00000110011100001100001000000000001110111001001001001110000110101001011010110100 +00111001000011111001111111001011000 +101010000111001010001010000000011001111101111110000011111000101101101 +011111110011011011001001001111111001101100111000001101011110000100110000001 +001011000 +001000010011100101100101011 +\N +010101111010011101110100100110 +0100100100100000111110111101 +000000010000110111100011100001101110111011110000001 +11111111001011011110010 +101000101000000110010010111001000001111001010100101001111000001100110111000000 +011010010100000101001011010001110010000010101111001101100011110110100010100111000000011 +11111100110010001100000100111100010000010 +01011010101000000100000111011011100100111101001001 +010111101111000001101001001110001000100001111101011010011011100101110000101110 +100000101 +10011111001000001001101111010101111010 +0010111011001001010100100000100 +0001010100010101111011111110101101010000 +011110001010001011101000111010011110000011000010001110010101010001111101 +11000100101010101101110001101111000000001100111010 +0001100100011101010101001100110110011111110010100100110 +10011000011000101111010101001000001000001010111001100101110101011101111001101000111111100101100100 +1000101111100110110111000001 +11000101110110001001110000010010000001111010101101011001100000101011101100000101 +100000111010100011010010010101 +110011110100110101011000101011110101010110001101001000110001110110110100010010001111111100100011 +0111111011111001010010101100110100011111110110001111001000001001001101100100111101100011010100 +1110010101001111101010011000000100100100011101011101110001110001101110110010100111110010001000011 +00110010100100010100111001100111000101100010000101110111101001 +1011001011010000101001100001111101010001101110010111100001001 +1101110100101110000001010110100100111111010100001011000110110101101000110101011110010 +111110000001000100101001011011101111010000111100011011111001101000011101110110001 +10000100101001010010101011100111101011000100011001110100000100010000110100100000001101 +0010110000100010101111000010010011011011100011110110110100101001100010000 +010011000110111110100000001110001001110011 +0101010100111111011000100100100110101001100100110 +1001100111000101100010000101110111101001101000001001011001100 +1101011110011000000100011011000110010111001101000111100111111001 +11000000000001001111011010010111001100010110100010001000 +000111001011000110001111111100110 +11111101111010101110110101101111110001110011100101101100000110011001000101010011001011 +110100111111100110100111010000101111111100110100000010010010000100010001 +00101000101000100000 +101100111100011100000110010 +011011101011101011110100111110010011100000101010100010 +011000010000111010110111110010010010011101000101101001001001100001101011 +1000101010001111001000010110110100000110111001010000101001000010101100101011100001011111101000000 +000111100100000100100110110010011110110001101010001110000010111101011011000100000111111101 +\N +101000011110101111111000000101111001001001 +0011010000001011111010100101010000001110101001010111010111011000101011101101000111101 +001111111110000101110100100101011010 +0101 +110011011101000001011010 +0110001111010110011111101010100110000011001110110000011100000110 +100101010110111011001001110000011010111111101110110001010111010001111000001010010 +00001110010011111100111101000100011010 +11110101011010000100111011100101010110011010010011110100101100100001100111100010100001 +1001011100000110100101111010010011001001111000010100101101010001000001010111011110010001111100 +110111110010011111001010101101011001001000111100111011001010101110000100110011001110101011000101 +1101001011111100111000111001 +0110100000110010100100010100111001100111000101100010000101 +10010110110110011110011110100110101011000101011110101010110001101001000110001110110110100 +0001000001011001101101101100101101111000110110000010011011101011101101100 +00101011110110100011011111001001111100101010110101100100100011110011101100101010111000010011001 +011011100110000 +0001001011011111010010100101010001101101010011101001110000110 +0101110010100010000001011010110010001010010010001010000100110 +00 +111100111111000110011001101101010 +\N +111011101 +0011110001100 +110100000000000101000111101011010100111100011110010011 +100000001100100100000010101111000111000011100000100001 +010101100011010010001100011101101101000100100011111111001000110101011100000111000000010 +011000000001110110111110001101100 +0100001110010010110 +10 +000011011100101100000010011010111010101010001111010010101111100 +1000 +001101000101110010000011 +10110010000100010010011100001100110100000000000101000 +0010110101011100111111000000011000001111010011100110000010001000101110001 +1010011100110111010000101111010110110110100001000010100101 +1000110110010010010011111110111000100001111111001010100001 +011011001110000010100001001011001010110001000011110100010010101101101011011000100110111 +11010001011010101101 +111110101100110010111010101110010100011001010011001111101110110010100 +000111101111101110110000110000000100101101001000010010001110110110001111001000 +00111101000000010111 +1101001011000101000101011111111000000011 +110111011111000110011011100011101100000100111100001010101011111111000100111011011001110110010010011 +000010110011011011011001011011110001101100000100110111010111011011001 +010011110001100001101110100011100111010111101110010 +11110110110011110001101100101110000001 +01001001101000101110011011010111110001100100110001001000111000101010111001010000111100 +1010111010101110010111 +1111110000000001010010000011 +110011111001001001000110111000110001100101100110100011010100111101 +101110111101001101000001001011001100001101001000001101 +01 +11001110110100000000000010101001100101100000111100000110101101000010 +1100000110110101111001101 +100 +00011110101110001001 +111110111010100111100011010011001001100111100110010 +0100111110000110100010111001011010111001011010100001001101101000000011000 +101111100110010110001110011011010111010001001100101001110110010111011111101 +00010011010111001111101 +10100011100001000111010110111 +0111010010111111101111110111101010101101010 +10111111011 +10001011010 +1000011111010110100110111001011100001011101100010001101000111110 +010100100111101110110111001110110011110 +000110101001111100110000101001111011101011001100000011010011 +000111 +10010001110110110001111001000101000101111010100110011101111101111100100011 +01111101010001110011001101000111001001101001111101000101110110011100001000100 +10100001110001 +0101100000100001100001010011001010010001110000110010000110010111101110011010110100011 +11101000100101010010111110 +11010010110111011011101110100110000000110100001101100101101010000111110011110100100110100011 +1100000000100100010110110101001101011010010100000111111110011100111011111111010111 +101110111001100111010001111001101110101001101100010000001000001100010101001000001101100110110000001 +01001011100100010001011 +0001010111010000000111010101001110101110000011010100 +110000111000011001001110111100001111111111001111101 +00110001000011100 +0110110011 +0011110111110000001011011101101100000 +0100011101011000011011100100110110011111000011001010010001011101111011001101100101001 +10 +1 +00111101111000100110101010001100001001111010101110000001001001100101010111111001010111001001 +011010011000110110100111010110000000111111111100100010111111101110101010111000000 +111000000100010100001111001011011001101011000101111001000100001010011101 +10100011110100101101111111010111100111100100101111100110010110001110011 +100100000011110111000001011100100000101001000101000001001100010 +0000100100010100101010010010110111011010110011110001101001010110100101 +0101100011110010101111110100001110010011101100000000011 +1001100111100100010110011111101011111101011011010011001101 +1100001000111101010001100111111101111010001100000 +010001111001101100100000111010110 +01000011001110010011001010000 +0111011100101010110011010010011110100101100100001100111100010100001000111 +011110111110000001011011101101100000 +101011010101101100010111111011011101110001011110010001001000001101001111001100011100011001000010 +0001100011101101101000100100011111111001000110101011100000111000000010000011 +11000111111000111110000000000110110101001110110100101011010101010101000010000000110 +1011 +1110110101110110010001011011110110000110000111111001011110010011010111001000111010010001 +110101100010110101000 +10110011011101101001111011110001001101010100011000010011110101011100000010010011001010101 +00011111100100010 +00 +01010010000001011010101000000100000111 +11010010110110101001110011011101010110101100010111011000100111 +10101000110011010000011000101110011000111110011111101111100110100011000011111001100100 +11111100001000011001101110110101101010111 +10110011000111011 +01000111100111 +0000110101010000010111111101101001011100111111101011010111001111110111000100010011001101011011100 +10011100010110000111101101111101100100101010000010011010111110101010110101011100011010011101000010 +110111110101000001111011110010010010010111110000100001001111001010010010010100110100 +001100000000 +10000101101110011110001000000110 +00101010101001101111000 +011000111001010000111101 +0110100000111000001111000101010000110110100101101100 +1011100101010110011010010011110100101100100001100111100010100001000111 diff --git a/contrib/btree_gist/expected/bit.out b/contrib/btree_gist/expected/bit.out new file mode 100644 index 0000000..e57871f --- /dev/null +++ b/contrib/btree_gist/expected/bit.out @@ -0,0 +1,76 @@ +-- bit check +CREATE TABLE bittmp (a bit(33)); +\copy bittmp from 'data/bit.data' +SET enable_seqscan=on; +SELECT count(*) FROM bittmp WHERE a < '011011000100010111011000110000100'; + count +------- + 249 +(1 row) + +SELECT count(*) FROM bittmp WHERE a <= '011011000100010111011000110000100'; + count +------- + 250 +(1 row) + +SELECT count(*) FROM bittmp WHERE a = '011011000100010111011000110000100'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM bittmp WHERE a >= '011011000100010111011000110000100'; + count +------- + 351 +(1 row) + +SELECT count(*) FROM bittmp WHERE a > '011011000100010111011000110000100'; + count +------- + 350 +(1 row) + +CREATE INDEX bitidx ON bittmp USING GIST ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM bittmp WHERE a < '011011000100010111011000110000100'; + count +------- + 249 +(1 row) + +SELECT count(*) FROM bittmp WHERE a <= '011011000100010111011000110000100'; + count +------- + 250 +(1 row) + +SELECT count(*) FROM bittmp WHERE a = '011011000100010111011000110000100'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM bittmp WHERE a >= '011011000100010111011000110000100'; + count +------- + 351 +(1 row) + +SELECT count(*) FROM bittmp WHERE a > '011011000100010111011000110000100'; + count +------- + 350 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT a FROM bittmp WHERE a BETWEEN '1000000' and '1000001'; + QUERY PLAN +--------------------------------------------------------------------- + Index Only Scan using bitidx on bittmp + Index Cond: ((a >= '1000000'::"bit") AND (a <= '1000001'::"bit")) +(2 rows) + diff --git a/contrib/btree_gist/expected/bool.out b/contrib/btree_gist/expected/bool.out new file mode 100644 index 0000000..c67a968 --- /dev/null +++ b/contrib/btree_gist/expected/bool.out @@ -0,0 +1,96 @@ +-- bool check +CREATE TABLE booltmp (a bool); +INSERT INTO booltmp VALUES (false), (true); +SET enable_seqscan=on; +SELECT count(*) FROM booltmp WHERE a < true; + count +------- + 1 +(1 row) + +SELECT count(*) FROM booltmp WHERE a <= true; + count +------- + 2 +(1 row) + +SELECT count(*) FROM booltmp WHERE a = true; + count +------- + 1 +(1 row) + +SELECT count(*) FROM booltmp WHERE a >= true; + count +------- + 1 +(1 row) + +SELECT count(*) FROM booltmp WHERE a > true; + count +------- + 0 +(1 row) + +CREATE INDEX boolidx ON booltmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM booltmp WHERE a < true; + count +------- + 1 +(1 row) + +SELECT count(*) FROM booltmp WHERE a <= true; + count +------- + 2 +(1 row) + +SELECT count(*) FROM booltmp WHERE a = true; + count +------- + 1 +(1 row) + +SELECT count(*) FROM booltmp WHERE a >= true; + count +------- + 1 +(1 row) + +SELECT count(*) FROM booltmp WHERE a > true; + count +------- + 0 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM booltmp WHERE a; + QUERY PLAN +------------------------------------------ + Index Only Scan using boolidx on booltmp + Filter: a +(2 rows) + +SELECT * FROM booltmp WHERE a; + a +--- + t +(1 row) + +EXPLAIN (COSTS OFF) +SELECT * FROM booltmp WHERE NOT a; + QUERY PLAN +------------------------------------------ + Index Only Scan using boolidx on booltmp + Filter: (NOT a) +(2 rows) + +SELECT * FROM booltmp WHERE NOT a; + a +--- + f +(1 row) + diff --git a/contrib/btree_gist/expected/bytea.out b/contrib/btree_gist/expected/bytea.out new file mode 100644 index 0000000..b9efa73 --- /dev/null +++ b/contrib/btree_gist/expected/bytea.out @@ -0,0 +1,90 @@ +-- bytea check +CREATE TABLE byteatmp (a bytea); +\copy byteatmp from 'data/text.data' +\copy byteatmp from 'data/char.data' +SET enable_seqscan=on; +SELECT count(*) FROM byteatmp WHERE a < '31b0'; + count +------- + 588 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a <= '31b0'; + count +------- + 589 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a = '31b0'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a >= '31b0'; + count +------- + 401 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a > '31b0'; + count +------- + 400 +(1 row) + +CREATE INDEX byteaidx ON byteatmp USING GIST ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM byteatmp WHERE a < '31b0'::bytea; + count +------- + 588 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a <= '31b0'::bytea; + count +------- + 589 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a = '31b0'::bytea; + count +------- + 1 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a >= '31b0'::bytea; + count +------- + 401 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a > '31b0'::bytea; + count +------- + 400 +(1 row) + +SELECT count(*) FROM byteatmp WHERE a = '2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809'::bytea; + count +------- + 1 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT a FROM byteatmp where a > 'ffa'::bytea; + QUERY PLAN +-------------------------------------------- + Index Only Scan using byteaidx on byteatmp + Index Cond: (a > '\x666661'::bytea) +(2 rows) + +SELECT a FROM byteatmp where a > 'ffa'::bytea; + a +-------------------------------- + \x666662656532373363376262 + \x6666626663313331336339633835 +(2 rows) + diff --git a/contrib/btree_gist/expected/cash.out b/contrib/btree_gist/expected/cash.out new file mode 100644 index 0000000..7fbc735 --- /dev/null +++ b/contrib/btree_gist/expected/cash.out @@ -0,0 +1,91 @@ +-- money check +CREATE TABLE moneytmp (a money); +\copy moneytmp from 'data/cash.data' +SET enable_seqscan=on; +SELECT count(*) FROM moneytmp WHERE a < '22649.64'; + count +------- + 289 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a <= '22649.64'; + count +------- + 290 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a = '22649.64'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a >= '22649.64'; + count +------- + 254 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a > '22649.64'; + count +------- + 253 +(1 row) + +SELECT a, a <-> '21472.79' FROM moneytmp ORDER BY a <-> '21472.79' LIMIT 3; + a | ?column? +------------+---------- + $21,472.79 | $0.00 + $21,469.25 | $3.54 + $21,915.01 | $442.22 +(3 rows) + +CREATE INDEX moneyidx ON moneytmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM moneytmp WHERE a < '22649.64'::money; + count +------- + 289 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a <= '22649.64'::money; + count +------- + 290 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a = '22649.64'::money; + count +------- + 1 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a >= '22649.64'::money; + count +------- + 254 +(1 row) + +SELECT count(*) FROM moneytmp WHERE a > '22649.64'::money; + count +------- + 253 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '21472.79' FROM moneytmp ORDER BY a <-> '21472.79' LIMIT 3; + QUERY PLAN +-------------------------------------------------- + Limit + -> Index Only Scan using moneyidx on moneytmp + Order By: (a <-> '$21,472.79'::money) +(3 rows) + +SELECT a, a <-> '21472.79' FROM moneytmp ORDER BY a <-> '21472.79' LIMIT 3; + a | ?column? +------------+---------- + $21,472.79 | $0.00 + $21,469.25 | $3.54 + $21,915.01 | $442.22 +(3 rows) + diff --git a/contrib/btree_gist/expected/char.out b/contrib/btree_gist/expected/char.out new file mode 100644 index 0000000..45cf9f3 --- /dev/null +++ b/contrib/btree_gist/expected/char.out @@ -0,0 +1,82 @@ +-- char check +CREATE TABLE chartmp (a char(32)); +\copy chartmp from 'data/char.data' +SET enable_seqscan=on; +SELECT count(*) FROM chartmp WHERE a < '31b0'::char(32); + count +------- + 587 +(1 row) + +SELECT count(*) FROM chartmp WHERE a <= '31b0'::char(32); + count +------- + 588 +(1 row) + +SELECT count(*) FROM chartmp WHERE a = '31b0'::char(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM chartmp WHERE a >= '31b0'::char(32); + count +------- + 401 +(1 row) + +SELECT count(*) FROM chartmp WHERE a > '31b0'::char(32); + count +------- + 400 +(1 row) + +CREATE INDEX charidx ON chartmp USING GIST ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM chartmp WHERE a < '31b0'::char(32); + count +------- + 587 +(1 row) + +SELECT count(*) FROM chartmp WHERE a <= '31b0'::char(32); + count +------- + 588 +(1 row) + +SELECT count(*) FROM chartmp WHERE a = '31b0'::char(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM chartmp WHERE a >= '31b0'::char(32); + count +------- + 401 +(1 row) + +SELECT count(*) FROM chartmp WHERE a > '31b0'::char(32); + count +------- + 400 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM chartmp WHERE a BETWEEN '31a' AND '31c'; + QUERY PLAN +--------------------------------------------------------------- + Index Only Scan using charidx on chartmp + Index Cond: ((a >= '31a'::bpchar) AND (a <= '31c'::bpchar)) +(2 rows) + +SELECT * FROM chartmp WHERE a BETWEEN '31a' AND '31c'; + a +---------------------------------- + 31b0 +(1 row) + diff --git a/contrib/btree_gist/expected/char_1.out b/contrib/btree_gist/expected/char_1.out new file mode 100644 index 0000000..7b7824b --- /dev/null +++ b/contrib/btree_gist/expected/char_1.out @@ -0,0 +1,82 @@ +-- char check +CREATE TABLE chartmp (a char(32)); +\copy chartmp from 'data/char.data' +SET enable_seqscan=on; +SELECT count(*) FROM chartmp WHERE a < '31b0'::char(32); + count +------- + 773 +(1 row) + +SELECT count(*) FROM chartmp WHERE a <= '31b0'::char(32); + count +------- + 774 +(1 row) + +SELECT count(*) FROM chartmp WHERE a = '31b0'::char(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM chartmp WHERE a >= '31b0'::char(32); + count +------- + 215 +(1 row) + +SELECT count(*) FROM chartmp WHERE a > '31b0'::char(32); + count +------- + 214 +(1 row) + +CREATE INDEX charidx ON chartmp USING GIST ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM chartmp WHERE a < '31b0'::char(32); + count +------- + 773 +(1 row) + +SELECT count(*) FROM chartmp WHERE a <= '31b0'::char(32); + count +------- + 774 +(1 row) + +SELECT count(*) FROM chartmp WHERE a = '31b0'::char(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM chartmp WHERE a >= '31b0'::char(32); + count +------- + 215 +(1 row) + +SELECT count(*) FROM chartmp WHERE a > '31b0'::char(32); + count +------- + 214 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM chartmp WHERE a BETWEEN '31a' AND '31c'; + QUERY PLAN +--------------------------------------------------------------- + Index Only Scan using charidx on chartmp + Index Cond: ((a >= '31a'::bpchar) AND (a <= '31c'::bpchar)) +(2 rows) + +SELECT * FROM chartmp WHERE a BETWEEN '31a' AND '31c'; + a +---------------------------------- + 31b0 +(1 row) + diff --git a/contrib/btree_gist/expected/cidr.out b/contrib/btree_gist/expected/cidr.out new file mode 100644 index 0000000..6d0995a --- /dev/null +++ b/contrib/btree_gist/expected/cidr.out @@ -0,0 +1,66 @@ +-- cidr check +CREATE TABLE cidrtmp AS + SELECT cidr(a) AS a FROM inettmp ; +SET enable_seqscan=on; +SELECT count(*) FROM cidrtmp WHERE a < '121.111.63.82'; + count +------- + 290 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a <= '121.111.63.82'; + count +------- + 291 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a = '121.111.63.82'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a >= '121.111.63.82'; + count +------- + 310 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a > '121.111.63.82'; + count +------- + 309 +(1 row) + +CREATE INDEX cidridx ON cidrtmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM cidrtmp WHERE a < '121.111.63.82'::cidr; + count +------- + 290 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a <= '121.111.63.82'::cidr; + count +------- + 291 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a = '121.111.63.82'::cidr; + count +------- + 1 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a >= '121.111.63.82'::cidr; + count +------- + 310 +(1 row) + +SELECT count(*) FROM cidrtmp WHERE a > '121.111.63.82'::cidr; + count +------- + 309 +(1 row) + diff --git a/contrib/btree_gist/expected/date.out b/contrib/btree_gist/expected/date.out new file mode 100644 index 0000000..5db864b --- /dev/null +++ b/contrib/btree_gist/expected/date.out @@ -0,0 +1,91 @@ +-- date check +CREATE TABLE datetmp (a date); +\copy datetmp from 'data/date.data' +SET enable_seqscan=on; +SELECT count(*) FROM datetmp WHERE a < '2001-02-13'; + count +------- + 230 +(1 row) + +SELECT count(*) FROM datetmp WHERE a <= '2001-02-13'; + count +------- + 231 +(1 row) + +SELECT count(*) FROM datetmp WHERE a = '2001-02-13'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM datetmp WHERE a >= '2001-02-13'; + count +------- + 314 +(1 row) + +SELECT count(*) FROM datetmp WHERE a > '2001-02-13'; + count +------- + 313 +(1 row) + +SELECT a, a <-> '2001-02-13' FROM datetmp ORDER BY a <-> '2001-02-13' LIMIT 3; + a | ?column? +------------+---------- + 02-13-2001 | 0 + 02-11-2001 | 2 + 03-24-2001 | 39 +(3 rows) + +CREATE INDEX dateidx ON datetmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM datetmp WHERE a < '2001-02-13'::date; + count +------- + 230 +(1 row) + +SELECT count(*) FROM datetmp WHERE a <= '2001-02-13'::date; + count +------- + 231 +(1 row) + +SELECT count(*) FROM datetmp WHERE a = '2001-02-13'::date; + count +------- + 1 +(1 row) + +SELECT count(*) FROM datetmp WHERE a >= '2001-02-13'::date; + count +------- + 314 +(1 row) + +SELECT count(*) FROM datetmp WHERE a > '2001-02-13'::date; + count +------- + 313 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '2001-02-13' FROM datetmp ORDER BY a <-> '2001-02-13' LIMIT 3; + QUERY PLAN +------------------------------------------------ + Limit + -> Index Only Scan using dateidx on datetmp + Order By: (a <-> '02-13-2001'::date) +(3 rows) + +SELECT a, a <-> '2001-02-13' FROM datetmp ORDER BY a <-> '2001-02-13' LIMIT 3; + a | ?column? +------------+---------- + 02-13-2001 | 0 + 02-11-2001 | 2 + 03-24-2001 | 39 +(3 rows) + diff --git a/contrib/btree_gist/expected/enum.out b/contrib/btree_gist/expected/enum.out new file mode 100644 index 0000000..c4b769d --- /dev/null +++ b/contrib/btree_gist/expected/enum.out @@ -0,0 +1,91 @@ +-- enum check +create type rainbow as enum ('r','o','y','g','b','i','v'); +CREATE TABLE enumtmp (a rainbow); +\copy enumtmp from 'data/enum.data' +SET enable_seqscan=on; +select a, count(*) from enumtmp group by a order by 1; + a | count +---+------- + r | 76 + o | 78 + y | 73 + g | 75 + b | 77 + i | 78 + v | 75 + | 63 +(8 rows) + +SELECT count(*) FROM enumtmp WHERE a < 'g'::rainbow; + count +------- + 227 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a <= 'g'::rainbow; + count +------- + 302 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a = 'g'::rainbow; + count +------- + 75 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a >= 'g'::rainbow; + count +------- + 305 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a > 'g'::rainbow; + count +------- + 230 +(1 row) + +CREATE INDEX enumidx ON enumtmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM enumtmp WHERE a < 'g'::rainbow; + count +------- + 227 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a <= 'g'::rainbow; + count +------- + 302 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a = 'g'::rainbow; + count +------- + 75 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a >= 'g'::rainbow; + count +------- + 305 +(1 row) + +SELECT count(*) FROM enumtmp WHERE a > 'g'::rainbow; + count +------- + 230 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT count(*) FROM enumtmp WHERE a >= 'g'::rainbow; + QUERY PLAN +----------------------------------------------- + Aggregate + -> Bitmap Heap Scan on enumtmp + Recheck Cond: (a >= 'g'::rainbow) + -> Bitmap Index Scan on enumidx + Index Cond: (a >= 'g'::rainbow) +(5 rows) + diff --git a/contrib/btree_gist/expected/float4.out b/contrib/btree_gist/expected/float4.out new file mode 100644 index 0000000..dfe7320 --- /dev/null +++ b/contrib/btree_gist/expected/float4.out @@ -0,0 +1,91 @@ +-- float4 check +CREATE TABLE float4tmp (a float4); +\copy float4tmp from 'data/float4.data' +SET enable_seqscan=on; +SELECT count(*) FROM float4tmp WHERE a < -179.0; + count +------- + 244 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a <= -179.0; + count +------- + 245 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a = -179.0; + count +------- + 1 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a >= -179.0; + count +------- + 303 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a > -179.0; + count +------- + 302 +(1 row) + +SELECT a, a <-> '-179.0' FROM float4tmp ORDER BY a <-> '-179.0' LIMIT 3; + a | ?column? +------------+----------- + -179 | 0 + -189.02386 | 10.023865 + -158.17741 | 20.822586 +(3 rows) + +CREATE INDEX float4idx ON float4tmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM float4tmp WHERE a < -179.0::float4; + count +------- + 244 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a <= -179.0::float4; + count +------- + 245 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a = -179.0::float4; + count +------- + 1 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a >= -179.0::float4; + count +------- + 303 +(1 row) + +SELECT count(*) FROM float4tmp WHERE a > -179.0::float4; + count +------- + 302 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '-179.0' FROM float4tmp ORDER BY a <-> '-179.0' LIMIT 3; + QUERY PLAN +---------------------------------------------------- + Limit + -> Index Only Scan using float4idx on float4tmp + Order By: (a <-> '-179'::real) +(3 rows) + +SELECT a, a <-> '-179.0' FROM float4tmp ORDER BY a <-> '-179.0' LIMIT 3; + a | ?column? +------------+----------- + -179 | 0 + -189.02386 | 10.023865 + -158.17741 | 20.822586 +(3 rows) + diff --git a/contrib/btree_gist/expected/float8.out b/contrib/btree_gist/expected/float8.out new file mode 100644 index 0000000..ebd0ef3 --- /dev/null +++ b/contrib/btree_gist/expected/float8.out @@ -0,0 +1,91 @@ +-- float8 check +CREATE TABLE float8tmp (a float8); +\copy float8tmp from 'data/float8.data' +SET enable_seqscan=on; +SELECT count(*) FROM float8tmp WHERE a < -1890.0; + count +------- + 237 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a <= -1890.0; + count +------- + 238 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a = -1890.0; + count +------- + 1 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a >= -1890.0; + count +------- + 307 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a > -1890.0; + count +------- + 306 +(1 row) + +SELECT a, a <-> '-1890.0' FROM float8tmp ORDER BY a <-> '-1890.0' LIMIT 3; + a | ?column? +--------------+-------------------- + -1890 | 0 + -2003.634512 | 113.63451200000009 + -1769.73634 | 120.26366000000007 +(3 rows) + +CREATE INDEX float8idx ON float8tmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM float8tmp WHERE a < -1890.0::float8; + count +------- + 237 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a <= -1890.0::float8; + count +------- + 238 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a = -1890.0::float8; + count +------- + 1 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a >= -1890.0::float8; + count +------- + 307 +(1 row) + +SELECT count(*) FROM float8tmp WHERE a > -1890.0::float8; + count +------- + 306 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '-1890.0' FROM float8tmp ORDER BY a <-> '-1890.0' LIMIT 3; + QUERY PLAN +----------------------------------------------------- + Limit + -> Index Only Scan using float8idx on float8tmp + Order By: (a <-> '-1890'::double precision) +(3 rows) + +SELECT a, a <-> '-1890.0' FROM float8tmp ORDER BY a <-> '-1890.0' LIMIT 3; + a | ?column? +--------------+-------------------- + -1890 | 0 + -2003.634512 | 113.63451200000009 + -1769.73634 | 120.26366000000007 +(3 rows) + diff --git a/contrib/btree_gist/expected/inet.out b/contrib/btree_gist/expected/inet.out new file mode 100644 index 0000000..f15f143 --- /dev/null +++ b/contrib/btree_gist/expected/inet.out @@ -0,0 +1,101 @@ +-- inet check +CREATE TABLE inettmp (a inet); +\copy inettmp from 'data/inet.data' +SET enable_seqscan=on; +SELECT count(*) FROM inettmp WHERE a < '89.225.196.191'; + count +------- + 213 +(1 row) + +SELECT count(*) FROM inettmp WHERE a <= '89.225.196.191'; + count +------- + 214 +(1 row) + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM inettmp WHERE a >= '89.225.196.191'; + count +------- + 387 +(1 row) + +SELECT count(*) FROM inettmp WHERE a > '89.225.196.191'; + count +------- + 386 +(1 row) + +CREATE INDEX inetidx ON inettmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM inettmp WHERE a < '89.225.196.191'::inet; + count +------- + 213 +(1 row) + +SELECT count(*) FROM inettmp WHERE a <= '89.225.196.191'::inet; + count +------- + 214 +(1 row) + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + count +------- + 1 +(1 row) + +SELECT count(*) FROM inettmp WHERE a >= '89.225.196.191'::inet; + count +------- + 387 +(1 row) + +SELECT count(*) FROM inettmp WHERE a > '89.225.196.191'::inet; + count +------- + 386 +(1 row) + +VACUUM ANALYZE inettmp; +-- gist_inet_ops lacks a fetch function, so this should not be index-only scan +EXPLAIN (COSTS OFF) +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + QUERY PLAN +-------------------------------------------------- + Aggregate + -> Index Scan using inetidx on inettmp + Index Cond: (a = '89.225.196.191'::inet) +(3 rows) + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + count +------- + 1 +(1 row) + +DROP INDEX inetidx; +CREATE INDEX ON inettmp USING gist (a gist_inet_ops, a inet_ops); +-- this can be an index-only scan, as long as the planner uses the right column +EXPLAIN (COSTS OFF) +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + QUERY PLAN +--------------------------------------------------------- + Aggregate + -> Index Only Scan using inettmp_a_a1_idx on inettmp + Index Cond: (a = '89.225.196.191'::inet) +(3 rows) + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + count +------- + 1 +(1 row) + diff --git a/contrib/btree_gist/expected/init.out b/contrib/btree_gist/expected/init.out new file mode 100644 index 0000000..ce4559d --- /dev/null +++ b/contrib/btree_gist/expected/init.out @@ -0,0 +1,9 @@ +CREATE EXTENSION btree_gist; +-- Check whether any of our opclasses fail amvalidate +SELECT amname, opcname +FROM pg_opclass opc LEFT JOIN pg_am am ON am.oid = opcmethod +WHERE opc.oid >= 16384 AND NOT amvalidate(opc.oid); + amname | opcname +--------+--------- +(0 rows) + diff --git a/contrib/btree_gist/expected/int2.out b/contrib/btree_gist/expected/int2.out new file mode 100644 index 0000000..50a3329 --- /dev/null +++ b/contrib/btree_gist/expected/int2.out @@ -0,0 +1,91 @@ +-- int2 check +CREATE TABLE int2tmp (a int2); +\copy int2tmp from 'data/int2.data' +SET enable_seqscan=on; +SELECT count(*) FROM int2tmp WHERE a < 237; + count +------- + 297 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a <= 237; + count +------- + 298 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a = 237; + count +------- + 1 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a >= 237; + count +------- + 249 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a > 237; + count +------- + 248 +(1 row) + +SELECT a, a <-> '237' FROM int2tmp ORDER BY a <-> '237' LIMIT 3; + a | ?column? +-----+---------- + 237 | 0 + 232 | 5 + 228 | 9 +(3 rows) + +CREATE INDEX int2idx ON int2tmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM int2tmp WHERE a < 237::int2; + count +------- + 297 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a <= 237::int2; + count +------- + 298 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a = 237::int2; + count +------- + 1 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a >= 237::int2; + count +------- + 249 +(1 row) + +SELECT count(*) FROM int2tmp WHERE a > 237::int2; + count +------- + 248 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '237' FROM int2tmp ORDER BY a <-> '237' LIMIT 3; + QUERY PLAN +------------------------------------------------ + Limit + -> Index Only Scan using int2idx on int2tmp + Order By: (a <-> '237'::smallint) +(3 rows) + +SELECT a, a <-> '237' FROM int2tmp ORDER BY a <-> '237' LIMIT 3; + a | ?column? +-----+---------- + 237 | 0 + 232 | 5 + 228 | 9 +(3 rows) + diff --git a/contrib/btree_gist/expected/int4.out b/contrib/btree_gist/expected/int4.out new file mode 100644 index 0000000..6bbdc7c --- /dev/null +++ b/contrib/btree_gist/expected/int4.out @@ -0,0 +1,91 @@ +-- int4 check +CREATE TABLE int4tmp (a int4); +\copy int4tmp from 'data/int2.data' +SET enable_seqscan=on; +SELECT count(*) FROM int4tmp WHERE a < 237; + count +------- + 297 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a <= 237; + count +------- + 298 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a = 237; + count +------- + 1 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a >= 237; + count +------- + 249 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a > 237; + count +------- + 248 +(1 row) + +SELECT a, a <-> '237' FROM int4tmp ORDER BY a <-> '237' LIMIT 3; + a | ?column? +-----+---------- + 237 | 0 + 232 | 5 + 228 | 9 +(3 rows) + +CREATE INDEX int4idx ON int4tmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM int4tmp WHERE a < 237::int4; + count +------- + 297 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a <= 237::int4; + count +------- + 298 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a = 237::int4; + count +------- + 1 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a >= 237::int4; + count +------- + 249 +(1 row) + +SELECT count(*) FROM int4tmp WHERE a > 237::int4; + count +------- + 248 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '237' FROM int4tmp ORDER BY a <-> '237' LIMIT 3; + QUERY PLAN +------------------------------------------------ + Limit + -> Index Only Scan using int4idx on int4tmp + Order By: (a <-> 237) +(3 rows) + +SELECT a, a <-> '237' FROM int4tmp ORDER BY a <-> '237' LIMIT 3; + a | ?column? +-----+---------- + 237 | 0 + 232 | 5 + 228 | 9 +(3 rows) + diff --git a/contrib/btree_gist/expected/int8.out b/contrib/btree_gist/expected/int8.out new file mode 100644 index 0000000..eff77c2 --- /dev/null +++ b/contrib/btree_gist/expected/int8.out @@ -0,0 +1,91 @@ +-- int8 check +CREATE TABLE int8tmp (a int8); +\copy int8tmp from 'data/int8.data' +SET enable_seqscan=on; +SELECT count(*) FROM int8tmp WHERE a < 464571291354841; + count +------- + 276 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a <= 464571291354841; + count +------- + 277 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a = 464571291354841; + count +------- + 1 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a >= 464571291354841; + count +------- + 271 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a > 464571291354841; + count +------- + 270 +(1 row) + +SELECT a, a <-> '464571291354841' FROM int8tmp ORDER BY a <-> '464571291354841' LIMIT 3; + a | ?column? +-----------------+---------------- + 464571291354841 | 0 + 457257666629329 | 7313624725512 + 478227196042750 | 13655904687909 +(3 rows) + +CREATE INDEX int8idx ON int8tmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM int8tmp WHERE a < 464571291354841::int8; + count +------- + 276 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a <= 464571291354841::int8; + count +------- + 277 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a = 464571291354841::int8; + count +------- + 1 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a >= 464571291354841::int8; + count +------- + 271 +(1 row) + +SELECT count(*) FROM int8tmp WHERE a > 464571291354841::int8; + count +------- + 270 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '464571291354841' FROM int8tmp ORDER BY a <-> '464571291354841' LIMIT 3; + QUERY PLAN +----------------------------------------------------- + Limit + -> Index Only Scan using int8idx on int8tmp + Order By: (a <-> '464571291354841'::bigint) +(3 rows) + +SELECT a, a <-> '464571291354841' FROM int8tmp ORDER BY a <-> '464571291354841' LIMIT 3; + a | ?column? +-----------------+---------------- + 464571291354841 | 0 + 457257666629329 | 7313624725512 + 478227196042750 | 13655904687909 +(3 rows) + diff --git a/contrib/btree_gist/expected/interval.out b/contrib/btree_gist/expected/interval.out new file mode 100644 index 0000000..4c3d494 --- /dev/null +++ b/contrib/btree_gist/expected/interval.out @@ -0,0 +1,109 @@ +-- interval check +CREATE TABLE intervaltmp (a interval); +\copy intervaltmp from 'data/interval.data' +SET enable_seqscan=on; +SELECT count(*) FROM intervaltmp WHERE a < '199 days 21:21:23'; + count +------- + 329 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a <= '199 days 21:21:23'; + count +------- + 330 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a = '199 days 21:21:23'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a >= '199 days 21:21:23'; + count +------- + 271 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a > '199 days 21:21:23'; + count +------- + 270 +(1 row) + +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; + a | ?column? +-------------------------------------+-------------------------------------- + @ 199 days 21 hours 21 mins 23 secs | @ 0 + @ 183 days 6 hours 52 mins 48 secs | @ 16 days 14 hours 28 mins 35 secs + @ 220 days 19 hours 5 mins 42 secs | @ 21 days -2 hours -15 mins -41 secs +(3 rows) + +CREATE INDEX intervalidx ON intervaltmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM intervaltmp WHERE a < '199 days 21:21:23'::interval; + count +------- + 329 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a <= '199 days 21:21:23'::interval; + count +------- + 330 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a = '199 days 21:21:23'::interval; + count +------- + 1 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a >= '199 days 21:21:23'::interval; + count +------- + 271 +(1 row) + +SELECT count(*) FROM intervaltmp WHERE a > '199 days 21:21:23'::interval; + count +------- + 270 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; + QUERY PLAN +--------------------------------------------------------------------------- + Limit + -> Index Only Scan using intervalidx on intervaltmp + Order By: (a <-> '@ 199 days 21 hours 21 mins 23 secs'::interval) +(3 rows) + +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; + a | ?column? +-------------------------------------+-------------------------------------- + @ 199 days 21 hours 21 mins 23 secs | @ 0 + @ 183 days 6 hours 52 mins 48 secs | @ 16 days 14 hours 28 mins 35 secs + @ 220 days 19 hours 5 mins 42 secs | @ 21 days -2 hours -15 mins -41 secs +(3 rows) + +SET enable_indexonlyscan=off; +EXPLAIN (COSTS OFF) +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; + QUERY PLAN +--------------------------------------------------------------------------- + Limit + -> Index Scan using intervalidx on intervaltmp + Order By: (a <-> '@ 199 days 21 hours 21 mins 23 secs'::interval) +(3 rows) + +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; + a | ?column? +-------------------------------------+-------------------------------------- + @ 199 days 21 hours 21 mins 23 secs | @ 0 + @ 183 days 6 hours 52 mins 48 secs | @ 16 days 14 hours 28 mins 35 secs + @ 220 days 19 hours 5 mins 42 secs | @ 21 days -2 hours -15 mins -41 secs +(3 rows) + diff --git a/contrib/btree_gist/expected/macaddr.out b/contrib/btree_gist/expected/macaddr.out new file mode 100644 index 0000000..c0a4c62 --- /dev/null +++ b/contrib/btree_gist/expected/macaddr.out @@ -0,0 +1,89 @@ +-- macaddr check +CREATE TABLE macaddrtmp (a macaddr); +\copy macaddrtmp from 'data/macaddr.data' +SET enable_seqscan=on; +SELECT count(*) FROM macaddrtmp WHERE a < '22:00:5c:e5:9b:0d'; + count +------- + 56 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a <= '22:00:5c:e5:9b:0d'; + count +------- + 60 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a = '22:00:5c:e5:9b:0d'; + count +------- + 4 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a >= '22:00:5c:e5:9b:0d'; + count +------- + 544 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a > '22:00:5c:e5:9b:0d'; + count +------- + 540 +(1 row) + +CREATE INDEX macaddridx ON macaddrtmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM macaddrtmp WHERE a < '22:00:5c:e5:9b:0d'::macaddr; + count +------- + 56 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a <= '22:00:5c:e5:9b:0d'::macaddr; + count +------- + 60 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a = '22:00:5c:e5:9b:0d'::macaddr; + count +------- + 4 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a >= '22:00:5c:e5:9b:0d'::macaddr; + count +------- + 544 +(1 row) + +SELECT count(*) FROM macaddrtmp WHERE a > '22:00:5c:e5:9b:0d'::macaddr; + count +------- + 540 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM macaddrtmp WHERE a < '02:03:04:05:06:07'::macaddr; + QUERY PLAN +-------------------------------------------------- + Index Only Scan using macaddridx on macaddrtmp + Index Cond: (a < '02:03:04:05:06:07'::macaddr) +(2 rows) + +SELECT * FROM macaddrtmp WHERE a < '02:03:04:05:06:07'::macaddr; + a +------------------- + 01:02:37:05:4f:36 + 01:02:37:05:4f:36 + 01:02:37:05:4f:36 + 01:02:37:05:4f:36 + 01:43:b5:79:eb:0f + 01:43:b5:79:eb:0f + 01:43:b5:79:eb:0f + 01:43:b5:79:eb:0f +(8 rows) + diff --git a/contrib/btree_gist/expected/macaddr8.out b/contrib/btree_gist/expected/macaddr8.out new file mode 100644 index 0000000..e5ec6a5 --- /dev/null +++ b/contrib/btree_gist/expected/macaddr8.out @@ -0,0 +1,89 @@ +-- macaddr check +CREATE TABLE macaddr8tmp (a macaddr8); +\copy macaddr8tmp from 'data/macaddr.data' +SET enable_seqscan=on; +SELECT count(*) FROM macaddr8tmp WHERE a < '22:00:5c:e5:9b:0d'; + count +------- + 56 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a <= '22:00:5c:e5:9b:0d'; + count +------- + 60 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a = '22:00:5c:e5:9b:0d'; + count +------- + 4 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a >= '22:00:5c:e5:9b:0d'; + count +------- + 544 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a > '22:00:5c:e5:9b:0d'; + count +------- + 540 +(1 row) + +CREATE INDEX macaddr8idx ON macaddr8tmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM macaddr8tmp WHERE a < '22:00:5c:e5:9b:0d'::macaddr8; + count +------- + 56 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a <= '22:00:5c:e5:9b:0d'::macaddr8; + count +------- + 60 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a = '22:00:5c:e5:9b:0d'::macaddr8; + count +------- + 4 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a >= '22:00:5c:e5:9b:0d'::macaddr8; + count +------- + 544 +(1 row) + +SELECT count(*) FROM macaddr8tmp WHERE a > '22:00:5c:e5:9b:0d'::macaddr8; + count +------- + 540 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM macaddr8tmp WHERE a < '02:03:04:05:06:07'::macaddr8; + QUERY PLAN +--------------------------------------------------------- + Index Only Scan using macaddr8idx on macaddr8tmp + Index Cond: (a < '02:03:04:ff:fe:05:06:07'::macaddr8) +(2 rows) + +SELECT * FROM macaddr8tmp WHERE a < '02:03:04:05:06:07'::macaddr8; + a +------------------------- + 01:02:37:ff:fe:05:4f:36 + 01:02:37:ff:fe:05:4f:36 + 01:02:37:ff:fe:05:4f:36 + 01:02:37:ff:fe:05:4f:36 + 01:43:b5:ff:fe:79:eb:0f + 01:43:b5:ff:fe:79:eb:0f + 01:43:b5:ff:fe:79:eb:0f + 01:43:b5:ff:fe:79:eb:0f +(8 rows) + diff --git a/contrib/btree_gist/expected/not_equal.out b/contrib/btree_gist/expected/not_equal.out new file mode 100644 index 0000000..85b1e86 --- /dev/null +++ b/contrib/btree_gist/expected/not_equal.out @@ -0,0 +1,41 @@ +SET enable_seqscan to false; +-- test search for "not equals" +CREATE TABLE test_ne ( + a TIMESTAMP, + b NUMERIC +); +CREATE INDEX test_ne_idx ON test_ne USING gist (a, b); +INSERT INTO test_ne SELECT '2009-01-01', 10.7 FROM generate_series(1,1000); +INSERT INTO test_ne VALUES('2007-02-03', -91.3); +INSERT INTO test_ne VALUES('2011-09-01', 43.7); +INSERT INTO test_ne SELECT '2009-01-01', 10.7 FROM generate_series(1,1000); +SET enable_indexscan to false; +EXPLAIN (COSTS OFF) SELECT * FROM test_ne WHERE a <> '2009-01-01' AND b <> 10.7; + QUERY PLAN +------------------------------------------------------------------------------------------------------ + Bitmap Heap Scan on test_ne + Recheck Cond: ((a <> 'Thu Jan 01 00:00:00 2009'::timestamp without time zone) AND (b <> 10.7)) + -> Bitmap Index Scan on test_ne_idx + Index Cond: ((a <> 'Thu Jan 01 00:00:00 2009'::timestamp without time zone) AND (b <> 10.7)) +(4 rows) + +SELECT * FROM test_ne WHERE a <> '2009-01-01' AND b <> 10.7; + a | b +--------------------------+------- + Sat Feb 03 00:00:00 2007 | -91.3 + Thu Sep 01 00:00:00 2011 | 43.7 +(2 rows) + +RESET enable_indexscan; +-- test search for "not equals" using an exclusion constraint +CREATE TABLE zoo ( + cage INTEGER, + animal TEXT, + EXCLUDE USING gist (cage WITH =, animal WITH <>) +); +INSERT INTO zoo VALUES(123, 'zebra'); +INSERT INTO zoo VALUES(123, 'zebra'); +INSERT INTO zoo VALUES(123, 'lion'); +ERROR: conflicting key value violates exclusion constraint "zoo_cage_animal_excl" +DETAIL: Key (cage, animal)=(123, lion) conflicts with existing key (cage, animal)=(123, zebra). +INSERT INTO zoo VALUES(124, 'lion'); diff --git a/contrib/btree_gist/expected/numeric.out b/contrib/btree_gist/expected/numeric.out new file mode 100644 index 0000000..ae839b8 --- /dev/null +++ b/contrib/btree_gist/expected/numeric.out @@ -0,0 +1,207 @@ +-- numeric check +CREATE TABLE numerictmp (a numeric); +\copy numerictmp from 'data/int8.data' +\copy numerictmp from 'data/numeric.data' +\copy numerictmp from 'data/float8.data' +SET enable_seqscan=on; +SELECT count(*) FROM numerictmp WHERE a < -1890.0; + count +------- + 505 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a <= -1890.0; + count +------- + 506 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a = -1890.0; + count +------- + 1 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a >= -1890.0; + count +------- + 597 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a > -1890.0; + count +------- + 596 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a < 'NaN' ; + count +------- + 1100 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a <= 'NaN' ; + count +------- + 1102 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a = 'NaN' ; + count +------- + 2 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a >= 'NaN' ; + count +------- + 2 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a > 'NaN' ; + count +------- + 0 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a < 0 ; + count +------- + 523 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a <= 0 ; + count +------- + 526 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a = 0 ; + count +------- + 3 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a >= 0 ; + count +------- + 579 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a > 0 ; + count +------- + 576 +(1 row) + +CREATE INDEX numericidx ON numerictmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM numerictmp WHERE a < -1890.0; + count +------- + 505 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a <= -1890.0; + count +------- + 506 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a = -1890.0; + count +------- + 1 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a >= -1890.0; + count +------- + 597 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a > -1890.0; + count +------- + 596 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a < 'NaN' ; + count +------- + 1100 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a <= 'NaN' ; + count +------- + 1102 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a = 'NaN' ; + count +------- + 2 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a >= 'NaN' ; + count +------- + 2 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a > 'NaN' ; + count +------- + 0 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a < 0 ; + count +------- + 523 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a <= 0 ; + count +------- + 526 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a = 0 ; + count +------- + 3 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a >= 0 ; + count +------- + 579 +(1 row) + +SELECT count(*) FROM numerictmp WHERE a > 0 ; + count +------- + 576 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM numerictmp WHERE a BETWEEN 1 AND 300 ORDER BY a; + QUERY PLAN +--------------------------------------------------------------------- + Sort + Sort Key: a + -> Index Only Scan using numericidx on numerictmp + Index Cond: ((a >= '1'::numeric) AND (a <= '300'::numeric)) +(4 rows) + +SELECT * FROM numerictmp WHERE a BETWEEN 1 AND 300 ORDER BY a; + a +------------ + 204.035430 + 207.400532 +(2 rows) + diff --git a/contrib/btree_gist/expected/oid.out b/contrib/btree_gist/expected/oid.out new file mode 100644 index 0000000..776bbb1 --- /dev/null +++ b/contrib/btree_gist/expected/oid.out @@ -0,0 +1,66 @@ +-- oid check +SET enable_seqscan=on; +CREATE TEMPORARY TABLE oidtmp (oid oid); +INSERT INTO oidtmp SELECT g.i::oid FROM generate_series(1, 1000) g(i); +SELECT count(*) FROM oidtmp WHERE oid < 17; + count +------- + 16 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid <= 17; + count +------- + 17 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid = 17; + count +------- + 1 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid >= 17; + count +------- + 984 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid > 17; + count +------- + 983 +(1 row) + +CREATE INDEX oididx ON oidtmp USING gist ( oid ); +SET enable_seqscan=off; +SELECT count(*) FROM oidtmp WHERE oid < 17; + count +------- + 16 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid <= 17; + count +------- + 17 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid = 17; + count +------- + 1 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid >= 17; + count +------- + 984 +(1 row) + +SELECT count(*) FROM oidtmp WHERE oid > 17; + count +------- + 983 +(1 row) + diff --git a/contrib/btree_gist/expected/text.out b/contrib/btree_gist/expected/text.out new file mode 100644 index 0000000..bb4e2e6 --- /dev/null +++ b/contrib/btree_gist/expected/text.out @@ -0,0 +1,89 @@ +-- text check +CREATE TABLE texttmp (a text); +\copy texttmp from 'data/text.data' +\copy texttmp from 'data/char.data' +SET enable_seqscan=on; +SELECT count(*) FROM texttmp WHERE a < '31b0'; + count +------- + 588 +(1 row) + +SELECT count(*) FROM texttmp WHERE a <= '31b0'; + count +------- + 589 +(1 row) + +SELECT count(*) FROM texttmp WHERE a = '31b0'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM texttmp WHERE a >= '31b0'; + count +------- + 401 +(1 row) + +SELECT count(*) FROM texttmp WHERE a > '31b0'; + count +------- + 400 +(1 row) + +CREATE INDEX textidx ON texttmp USING GIST ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM texttmp WHERE a < '31b0'::text; + count +------- + 588 +(1 row) + +SELECT count(*) FROM texttmp WHERE a <= '31b0'::text; + count +------- + 589 +(1 row) + +SELECT count(*) FROM texttmp WHERE a = '31b0'::text; + count +------- + 1 +(1 row) + +SELECT count(*) FROM texttmp WHERE a >= '31b0'::text; + count +------- + 401 +(1 row) + +SELECT count(*) FROM texttmp WHERE a > '31b0'::text; + count +------- + 400 +(1 row) + +SELECT count(*) FROM texttmp WHERE a = '2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809'::text; + count +------- + 1 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM texttmp WHERE a BETWEEN '31a' AND '31c'; + QUERY PLAN +----------------------------------------------------------- + Index Only Scan using textidx on texttmp + Index Cond: ((a >= '31a'::text) AND (a <= '31c'::text)) +(2 rows) + +SELECT * FROM texttmp WHERE a BETWEEN '31a' AND '31c'; + a +------ + 31b0 +(1 row) + diff --git a/contrib/btree_gist/expected/text_1.out b/contrib/btree_gist/expected/text_1.out new file mode 100644 index 0000000..8ef1ffb --- /dev/null +++ b/contrib/btree_gist/expected/text_1.out @@ -0,0 +1,89 @@ +-- text check +CREATE TABLE texttmp (a text); +\copy texttmp from 'data/text.data' +\copy texttmp from 'data/char.data' +SET enable_seqscan=on; +SELECT count(*) FROM texttmp WHERE a < '31b0'; + count +------- + 774 +(1 row) + +SELECT count(*) FROM texttmp WHERE a <= '31b0'; + count +------- + 775 +(1 row) + +SELECT count(*) FROM texttmp WHERE a = '31b0'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM texttmp WHERE a >= '31b0'; + count +------- + 215 +(1 row) + +SELECT count(*) FROM texttmp WHERE a > '31b0'; + count +------- + 214 +(1 row) + +CREATE INDEX textidx ON texttmp USING GIST ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM texttmp WHERE a < '31b0'::text; + count +------- + 774 +(1 row) + +SELECT count(*) FROM texttmp WHERE a <= '31b0'::text; + count +------- + 775 +(1 row) + +SELECT count(*) FROM texttmp WHERE a = '31b0'::text; + count +------- + 1 +(1 row) + +SELECT count(*) FROM texttmp WHERE a >= '31b0'::text; + count +------- + 215 +(1 row) + +SELECT count(*) FROM texttmp WHERE a > '31b0'::text; + count +------- + 214 +(1 row) + +SELECT count(*) FROM texttmp WHERE a = '2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809'::text; + count +------- + 1 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM texttmp WHERE a BETWEEN '31a' AND '31c'; + QUERY PLAN +----------------------------------------------------------- + Index Only Scan using textidx on texttmp + Index Cond: ((a >= '31a'::text) AND (a <= '31c'::text)) +(2 rows) + +SELECT * FROM texttmp WHERE a BETWEEN '31a' AND '31c'; + a +------ + 31b0 +(1 row) + diff --git a/contrib/btree_gist/expected/time.out b/contrib/btree_gist/expected/time.out new file mode 100644 index 0000000..ec95ef7 --- /dev/null +++ b/contrib/btree_gist/expected/time.out @@ -0,0 +1,91 @@ +-- time check +CREATE TABLE timetmp (a time); +\copy timetmp from 'data/time.data' +SET enable_seqscan=on; +SELECT count(*) FROM timetmp WHERE a < '10:57:11'; + count +------- + 251 +(1 row) + +SELECT count(*) FROM timetmp WHERE a <= '10:57:11'; + count +------- + 252 +(1 row) + +SELECT count(*) FROM timetmp WHERE a = '10:57:11'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM timetmp WHERE a >= '10:57:11'; + count +------- + 293 +(1 row) + +SELECT count(*) FROM timetmp WHERE a > '10:57:11'; + count +------- + 292 +(1 row) + +SELECT a, a <-> '10:57:11' FROM timetmp ORDER BY a <-> '10:57:11' LIMIT 3; + a | ?column? +----------+----------------- + 10:57:11 | @ 0 + 10:57:10 | @ 1 sec + 10:55:32 | @ 1 min 39 secs +(3 rows) + +CREATE INDEX timeidx ON timetmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM timetmp WHERE a < '10:57:11'::time; + count +------- + 251 +(1 row) + +SELECT count(*) FROM timetmp WHERE a <= '10:57:11'::time; + count +------- + 252 +(1 row) + +SELECT count(*) FROM timetmp WHERE a = '10:57:11'::time; + count +------- + 1 +(1 row) + +SELECT count(*) FROM timetmp WHERE a >= '10:57:11'::time; + count +------- + 293 +(1 row) + +SELECT count(*) FROM timetmp WHERE a > '10:57:11'::time; + count +------- + 292 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '10:57:11' FROM timetmp ORDER BY a <-> '10:57:11' LIMIT 3; + QUERY PLAN +-------------------------------------------------------------- + Limit + -> Index Only Scan using timeidx on timetmp + Order By: (a <-> '10:57:11'::time without time zone) +(3 rows) + +SELECT a, a <-> '10:57:11' FROM timetmp ORDER BY a <-> '10:57:11' LIMIT 3; + a | ?column? +----------+----------------- + 10:57:11 | @ 0 + 10:57:10 | @ 1 sec + 10:55:32 | @ 1 min 39 secs +(3 rows) + diff --git a/contrib/btree_gist/expected/timestamp.out b/contrib/btree_gist/expected/timestamp.out new file mode 100644 index 0000000..0d94f2f --- /dev/null +++ b/contrib/btree_gist/expected/timestamp.out @@ -0,0 +1,91 @@ +-- timestamp check +CREATE TABLE timestamptmp (a timestamp); +\copy timestamptmp from 'data/timestamp.data' +SET enable_seqscan=on; +SELECT count(*) FROM timestamptmp WHERE a < '2004-10-26 08:55:08'; + count +------- + 278 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a <= '2004-10-26 08:55:08'; + count +------- + 279 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a = '2004-10-26 08:55:08'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a >= '2004-10-26 08:55:08'; + count +------- + 290 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a > '2004-10-26 08:55:08'; + count +------- + 289 +(1 row) + +SELECT a, a <-> '2004-10-26 08:55:08' FROM timestamptmp ORDER BY a <-> '2004-10-26 08:55:08' LIMIT 3; + a | ?column? +--------------------------+------------------------------------ + Tue Oct 26 08:55:08 2004 | @ 0 + Sun Oct 31 06:35:03 2004 | @ 4 days 21 hours 39 mins 55 secs + Mon Nov 29 20:12:43 2004 | @ 34 days 11 hours 17 mins 35 secs +(3 rows) + +CREATE INDEX timestampidx ON timestamptmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM timestamptmp WHERE a < '2004-10-26 08:55:08'::timestamp; + count +------- + 278 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a <= '2004-10-26 08:55:08'::timestamp; + count +------- + 279 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a = '2004-10-26 08:55:08'::timestamp; + count +------- + 1 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a >= '2004-10-26 08:55:08'::timestamp; + count +------- + 290 +(1 row) + +SELECT count(*) FROM timestamptmp WHERE a > '2004-10-26 08:55:08'::timestamp; + count +------- + 289 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '2004-10-26 08:55:08' FROM timestamptmp ORDER BY a <-> '2004-10-26 08:55:08' LIMIT 3; + QUERY PLAN +----------------------------------------------------------------------------------- + Limit + -> Index Only Scan using timestampidx on timestamptmp + Order By: (a <-> 'Tue Oct 26 08:55:08 2004'::timestamp without time zone) +(3 rows) + +SELECT a, a <-> '2004-10-26 08:55:08' FROM timestamptmp ORDER BY a <-> '2004-10-26 08:55:08' LIMIT 3; + a | ?column? +--------------------------+------------------------------------ + Tue Oct 26 08:55:08 2004 | @ 0 + Sun Oct 31 06:35:03 2004 | @ 4 days 21 hours 39 mins 55 secs + Mon Nov 29 20:12:43 2004 | @ 34 days 11 hours 17 mins 35 secs +(3 rows) + diff --git a/contrib/btree_gist/expected/timestamptz.out b/contrib/btree_gist/expected/timestamptz.out new file mode 100644 index 0000000..75a15a4 --- /dev/null +++ b/contrib/btree_gist/expected/timestamptz.out @@ -0,0 +1,211 @@ +-- timestamptz check +CREATE TABLE timestamptztmp (a timestamptz); +\copy timestamptztmp from 'data/timestamptz.data' +SET enable_seqscan=on; +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+3'; + count +------- + 391 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+3'; + count +------- + 392 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+3'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+3'; + count +------- + 158 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+3'; + count +------- + 157 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+2'; + count +------- + 391 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+2'; + count +------- + 391 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+2'; + count +------- + 0 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+2'; + count +------- + 158 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+2'; + count +------- + 158 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+4'; + count +------- + 392 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+4'; + count +------- + 392 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+4'; + count +------- + 0 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+4'; + count +------- + 157 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+4'; + count +------- + 157 +(1 row) + +SELECT a, a <-> '2018-12-18 10:59:54 GMT+2' FROM timestamptztmp ORDER BY a <-> '2018-12-18 10:59:54 GMT+2' LIMIT 3; + a | ?column? +------------------------------+----------------------------------- + Tue Dec 18 05:59:54 2018 PST | @ 1 hour + Thu Jan 10 03:01:34 2019 PST | @ 22 days 22 hours 1 min 40 secs + Thu Jan 24 12:28:12 2019 PST | @ 37 days 7 hours 28 mins 18 secs +(3 rows) + +CREATE INDEX timestamptzidx ON timestamptztmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+3'::timestamptz; + count +------- + 391 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+3'::timestamptz; + count +------- + 392 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+3'::timestamptz; + count +------- + 1 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+3'::timestamptz; + count +------- + 158 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+3'::timestamptz; + count +------- + 157 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+2'::timestamptz; + count +------- + 391 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+2'::timestamptz; + count +------- + 391 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+2'::timestamptz; + count +------- + 0 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+2'::timestamptz; + count +------- + 158 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+2'::timestamptz; + count +------- + 158 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+4'::timestamptz; + count +------- + 392 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+4'::timestamptz; + count +------- + 392 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+4'::timestamptz; + count +------- + 0 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+4'::timestamptz; + count +------- + 157 +(1 row) + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+4'::timestamptz; + count +------- + 157 +(1 row) + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '2018-12-18 10:59:54 GMT+2' FROM timestamptztmp ORDER BY a <-> '2018-12-18 10:59:54 GMT+2' LIMIT 3; + QUERY PLAN +------------------------------------------------------------------------------------ + Limit + -> Index Only Scan using timestamptzidx on timestamptztmp + Order By: (a <-> 'Tue Dec 18 04:59:54 2018 PST'::timestamp with time zone) +(3 rows) + +SELECT a, a <-> '2018-12-18 10:59:54 GMT+2' FROM timestamptztmp ORDER BY a <-> '2018-12-18 10:59:54 GMT+2' LIMIT 3; + a | ?column? +------------------------------+----------------------------------- + Tue Dec 18 05:59:54 2018 PST | @ 1 hour + Thu Jan 10 03:01:34 2019 PST | @ 22 days 22 hours 1 min 40 secs + Thu Jan 24 12:28:12 2019 PST | @ 37 days 7 hours 28 mins 18 secs +(3 rows) + diff --git a/contrib/btree_gist/expected/timetz.out b/contrib/btree_gist/expected/timetz.out new file mode 100644 index 0000000..7f73e44 --- /dev/null +++ b/contrib/btree_gist/expected/timetz.out @@ -0,0 +1,43 @@ +-- timetz check +CREATE TABLE timetztmp (a timetz); +\copy timetztmp from 'data/timetz.data' +CREATE TABLE timetzcmp ( r_id int2, a int4, b int4 ); +SET enable_seqscan=on; +INSERT INTO timetzcmp (r_id,a) SELECT 1,count(*) FROM timetztmp WHERE a < '07:46:45 GMT+3'; +INSERT INTO timetzcmp (r_id,a) SELECT 2,count(*) FROM timetztmp WHERE a <= '07:46:45 GMT+3'; +INSERT INTO timetzcmp (r_id,a) SELECT 3,count(*) FROM timetztmp WHERE a = '07:46:45 GMT+3'; +INSERT INTO timetzcmp (r_id,a) SELECT 4,count(*) FROM timetztmp WHERE a >= '07:46:45 GMT+3'; +INSERT INTO timetzcmp (r_id,a) SELECT 5,count(*) FROM timetztmp WHERE a > '07:46:45 GMT+3'; +INSERT INTO timetzcmp (r_id,a) SELECT 11,count(*) FROM timetztmp WHERE a < '07:46:45 GMT+2'; +INSERT INTO timetzcmp (r_id,a) SELECT 12,count(*) FROM timetztmp WHERE a <= '07:46:45 GMT+2'; +INSERT INTO timetzcmp (r_id,a) SELECT 13,count(*) FROM timetztmp WHERE a = '07:46:45 GMT+2'; +INSERT INTO timetzcmp (r_id,a) SELECT 14,count(*) FROM timetztmp WHERE a >= '07:46:45 GMT+2'; +INSERT INTO timetzcmp (r_id,a) SELECT 15,count(*) FROM timetztmp WHERE a > '07:46:45 GMT+2'; +INSERT INTO timetzcmp (r_id,a) SELECT 21,count(*) FROM timetztmp WHERE a < '07:46:45 GMT+4'; +INSERT INTO timetzcmp (r_id,a) SELECT 22,count(*) FROM timetztmp WHERE a <= '07:46:45 GMT+4'; +INSERT INTO timetzcmp (r_id,a) SELECT 23,count(*) FROM timetztmp WHERE a = '07:46:45 GMT+4'; +INSERT INTO timetzcmp (r_id,a) SELECT 24,count(*) FROM timetztmp WHERE a >= '07:46:45 GMT+4'; +INSERT INTO timetzcmp (r_id,a) SELECT 25,count(*) FROM timetztmp WHERE a > '07:46:45 GMT+4'; +CREATE INDEX timetzidx ON timetztmp USING gist ( a ); +SET enable_seqscan=off; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a < '07:46:45 GMT+3'::timetz ) q WHERE r_id=1 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a <= '07:46:45 GMT+3'::timetz ) q WHERE r_id=2 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a = '07:46:45 GMT+3'::timetz ) q WHERE r_id=3 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a >= '07:46:45 GMT+3'::timetz ) q WHERE r_id=4 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a > '07:46:45 GMT+3'::timetz ) q WHERE r_id=5 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a < '07:46:45 GMT+2'::timetz ) q WHERE r_id=11 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a <= '07:46:45 GMT+2'::timetz ) q WHERE r_id=12 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a = '07:46:45 GMT+2'::timetz ) q WHERE r_id=13 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a >= '07:46:45 GMT+2'::timetz ) q WHERE r_id=14 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a > '07:46:45 GMT+2'::timetz ) q WHERE r_id=15 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a < '07:46:45 GMT+4'::timetz ) q WHERE r_id=21 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a <= '07:46:45 GMT+4'::timetz ) q WHERE r_id=22 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a = '07:46:45 GMT+4'::timetz ) q WHERE r_id=23 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a >= '07:46:45 GMT+4'::timetz ) q WHERE r_id=24 ; +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a > '07:46:45 GMT+4'::timetz ) q WHERE r_id=25 ; +SELECT count(*) FROM timetzcmp WHERE a=b; + count +------- + 15 +(1 row) + diff --git a/contrib/btree_gist/expected/uuid.out b/contrib/btree_gist/expected/uuid.out new file mode 100644 index 0000000..a34b024 --- /dev/null +++ b/contrib/btree_gist/expected/uuid.out @@ -0,0 +1,66 @@ +-- uuid check +CREATE TABLE uuidtmp (a uuid); +\copy uuidtmp from 'data/uuid.data' +SET enable_seqscan=on; +SELECT count(*) FROM uuidtmp WHERE a < '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + count +------- + 227 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a <= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + count +------- + 228 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a = '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a >= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + count +------- + 376 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a > '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + count +------- + 375 +(1 row) + +CREATE INDEX uuididx ON uuidtmp USING gist ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM uuidtmp WHERE a < '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + count +------- + 227 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a <= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + count +------- + 228 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a = '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + count +------- + 1 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a >= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + count +------- + 376 +(1 row) + +SELECT count(*) FROM uuidtmp WHERE a > '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + count +------- + 375 +(1 row) + diff --git a/contrib/btree_gist/expected/varbit.out b/contrib/btree_gist/expected/varbit.out new file mode 100644 index 0000000..ede36bc --- /dev/null +++ b/contrib/btree_gist/expected/varbit.out @@ -0,0 +1,76 @@ +-- varbit check +CREATE TABLE varbittmp (a varbit); +\copy varbittmp from 'data/varbit.data' +SET enable_seqscan=on; +SELECT count(*) FROM varbittmp WHERE a < '1110100111010'; + count +------- + 549 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a <= '1110100111010'; + count +------- + 550 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a = '1110100111010'; + count +------- + 1 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a >= '1110100111010'; + count +------- + 51 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a > '1110100111010'; + count +------- + 50 +(1 row) + +CREATE INDEX varbitidx ON varbittmp USING GIST ( a ); +SET enable_seqscan=off; +SELECT count(*) FROM varbittmp WHERE a < '1110100111010'::varbit; + count +------- + 549 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a <= '1110100111010'::varbit; + count +------- + 550 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a = '1110100111010'::varbit; + count +------- + 1 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a >= '1110100111010'::varbit; + count +------- + 51 +(1 row) + +SELECT count(*) FROM varbittmp WHERE a > '1110100111010'::varbit; + count +------- + 50 +(1 row) + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT a FROM bittmp WHERE a BETWEEN '1000000' and '1000001'; + QUERY PLAN +--------------------------------------------------------------------- + Index Only Scan using bitidx on bittmp + Index Cond: ((a >= '1000000'::"bit") AND (a <= '1000001'::"bit")) +(2 rows) + diff --git a/contrib/btree_gist/expected/varchar.out b/contrib/btree_gist/expected/varchar.out new file mode 100644 index 0000000..d071d71 --- /dev/null +++ b/contrib/btree_gist/expected/varchar.out @@ -0,0 +1,66 @@ +-- char check +CREATE TABLE vchartmp (a varchar(32)); +\copy vchartmp from 'data/char.data' +SET enable_seqscan=on; +SELECT count(*) FROM vchartmp WHERE a < '31b0'::varchar(32); + count +------- + 587 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a <= '31b0'::varchar(32); + count +------- + 588 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a = '31b0'::varchar(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a >= '31b0'::varchar(32); + count +------- + 401 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a > '31b0'::varchar(32); + count +------- + 400 +(1 row) + +CREATE INDEX vcharidx ON vchartmp USING GIST ( text(a) ); +SET enable_seqscan=off; +SELECT count(*) FROM vchartmp WHERE a < '31b0'::varchar(32); + count +------- + 587 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a <= '31b0'::varchar(32); + count +------- + 588 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a = '31b0'::varchar(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a >= '31b0'::varchar(32); + count +------- + 401 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a > '31b0'::varchar(32); + count +------- + 400 +(1 row) + diff --git a/contrib/btree_gist/expected/varchar_1.out b/contrib/btree_gist/expected/varchar_1.out new file mode 100644 index 0000000..e4099d2 --- /dev/null +++ b/contrib/btree_gist/expected/varchar_1.out @@ -0,0 +1,66 @@ +-- char check +CREATE TABLE vchartmp (a varchar(32)); +\copy vchartmp from 'data/char.data' +SET enable_seqscan=on; +SELECT count(*) FROM vchartmp WHERE a < '31b0'::varchar(32); + count +------- + 773 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a <= '31b0'::varchar(32); + count +------- + 774 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a = '31b0'::varchar(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a >= '31b0'::varchar(32); + count +------- + 215 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a > '31b0'::varchar(32); + count +------- + 214 +(1 row) + +CREATE INDEX vcharidx ON vchartmp USING GIST ( text(a) ); +SET enable_seqscan=off; +SELECT count(*) FROM vchartmp WHERE a < '31b0'::varchar(32); + count +------- + 773 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a <= '31b0'::varchar(32); + count +------- + 774 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a = '31b0'::varchar(32); + count +------- + 1 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a >= '31b0'::varchar(32); + count +------- + 215 +(1 row) + +SELECT count(*) FROM vchartmp WHERE a > '31b0'::varchar(32); + count +------- + 214 +(1 row) + diff --git a/contrib/btree_gist/sql/bit.sql b/contrib/btree_gist/sql/bit.sql new file mode 100644 index 0000000..a733042 --- /dev/null +++ b/contrib/btree_gist/sql/bit.sql @@ -0,0 +1,36 @@ +-- bit check + +CREATE TABLE bittmp (a bit(33)); + +\copy bittmp from 'data/bit.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM bittmp WHERE a < '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a <= '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a = '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a >= '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a > '011011000100010111011000110000100'; + +CREATE INDEX bitidx ON bittmp USING GIST ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM bittmp WHERE a < '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a <= '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a = '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a >= '011011000100010111011000110000100'; + +SELECT count(*) FROM bittmp WHERE a > '011011000100010111011000110000100'; + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT a FROM bittmp WHERE a BETWEEN '1000000' and '1000001'; diff --git a/contrib/btree_gist/sql/bool.sql b/contrib/btree_gist/sql/bool.sql new file mode 100644 index 0000000..4c2a539 --- /dev/null +++ b/contrib/btree_gist/sql/bool.sql @@ -0,0 +1,42 @@ +-- bool check + +CREATE TABLE booltmp (a bool); + +INSERT INTO booltmp VALUES (false), (true); + +SET enable_seqscan=on; + +SELECT count(*) FROM booltmp WHERE a < true; + +SELECT count(*) FROM booltmp WHERE a <= true; + +SELECT count(*) FROM booltmp WHERE a = true; + +SELECT count(*) FROM booltmp WHERE a >= true; + +SELECT count(*) FROM booltmp WHERE a > true; + +CREATE INDEX boolidx ON booltmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM booltmp WHERE a < true; + +SELECT count(*) FROM booltmp WHERE a <= true; + +SELECT count(*) FROM booltmp WHERE a = true; + +SELECT count(*) FROM booltmp WHERE a >= true; + +SELECT count(*) FROM booltmp WHERE a > true; + +-- Test index-only scans +SET enable_bitmapscan=off; + +EXPLAIN (COSTS OFF) +SELECT * FROM booltmp WHERE a; +SELECT * FROM booltmp WHERE a; + +EXPLAIN (COSTS OFF) +SELECT * FROM booltmp WHERE NOT a; +SELECT * FROM booltmp WHERE NOT a; diff --git a/contrib/btree_gist/sql/bytea.sql b/contrib/btree_gist/sql/bytea.sql new file mode 100644 index 0000000..6885f5e --- /dev/null +++ b/contrib/btree_gist/sql/bytea.sql @@ -0,0 +1,40 @@ +-- bytea check + +CREATE TABLE byteatmp (a bytea); + +\copy byteatmp from 'data/text.data' +\copy byteatmp from 'data/char.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM byteatmp WHERE a < '31b0'; + +SELECT count(*) FROM byteatmp WHERE a <= '31b0'; + +SELECT count(*) FROM byteatmp WHERE a = '31b0'; + +SELECT count(*) FROM byteatmp WHERE a >= '31b0'; + +SELECT count(*) FROM byteatmp WHERE a > '31b0'; + +CREATE INDEX byteaidx ON byteatmp USING GIST ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM byteatmp WHERE a < '31b0'::bytea; + +SELECT count(*) FROM byteatmp WHERE a <= '31b0'::bytea; + +SELECT count(*) FROM byteatmp WHERE a = '31b0'::bytea; + +SELECT count(*) FROM byteatmp WHERE a >= '31b0'::bytea; + +SELECT count(*) FROM byteatmp WHERE a > '31b0'::bytea; + +SELECT count(*) FROM byteatmp WHERE a = '2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809'::bytea; + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT a FROM byteatmp where a > 'ffa'::bytea; +SELECT a FROM byteatmp where a > 'ffa'::bytea; diff --git a/contrib/btree_gist/sql/cash.sql b/contrib/btree_gist/sql/cash.sql new file mode 100644 index 0000000..4526cc4 --- /dev/null +++ b/contrib/btree_gist/sql/cash.sql @@ -0,0 +1,37 @@ +-- money check + +CREATE TABLE moneytmp (a money); + +\copy moneytmp from 'data/cash.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM moneytmp WHERE a < '22649.64'; + +SELECT count(*) FROM moneytmp WHERE a <= '22649.64'; + +SELECT count(*) FROM moneytmp WHERE a = '22649.64'; + +SELECT count(*) FROM moneytmp WHERE a >= '22649.64'; + +SELECT count(*) FROM moneytmp WHERE a > '22649.64'; + +SELECT a, a <-> '21472.79' FROM moneytmp ORDER BY a <-> '21472.79' LIMIT 3; + +CREATE INDEX moneyidx ON moneytmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM moneytmp WHERE a < '22649.64'::money; + +SELECT count(*) FROM moneytmp WHERE a <= '22649.64'::money; + +SELECT count(*) FROM moneytmp WHERE a = '22649.64'::money; + +SELECT count(*) FROM moneytmp WHERE a >= '22649.64'::money; + +SELECT count(*) FROM moneytmp WHERE a > '22649.64'::money; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '21472.79' FROM moneytmp ORDER BY a <-> '21472.79' LIMIT 3; +SELECT a, a <-> '21472.79' FROM moneytmp ORDER BY a <-> '21472.79' LIMIT 3; diff --git a/contrib/btree_gist/sql/char.sql b/contrib/btree_gist/sql/char.sql new file mode 100644 index 0000000..f6eb52e --- /dev/null +++ b/contrib/btree_gist/sql/char.sql @@ -0,0 +1,37 @@ +-- char check + +CREATE TABLE chartmp (a char(32)); + +\copy chartmp from 'data/char.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM chartmp WHERE a < '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a <= '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a = '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a >= '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a > '31b0'::char(32); + +CREATE INDEX charidx ON chartmp USING GIST ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM chartmp WHERE a < '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a <= '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a = '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a >= '31b0'::char(32); + +SELECT count(*) FROM chartmp WHERE a > '31b0'::char(32); + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM chartmp WHERE a BETWEEN '31a' AND '31c'; +SELECT * FROM chartmp WHERE a BETWEEN '31a' AND '31c'; diff --git a/contrib/btree_gist/sql/cidr.sql b/contrib/btree_gist/sql/cidr.sql new file mode 100644 index 0000000..9bd7718 --- /dev/null +++ b/contrib/btree_gist/sql/cidr.sql @@ -0,0 +1,30 @@ +-- cidr check + +CREATE TABLE cidrtmp AS + SELECT cidr(a) AS a FROM inettmp ; + +SET enable_seqscan=on; + +SELECT count(*) FROM cidrtmp WHERE a < '121.111.63.82'; + +SELECT count(*) FROM cidrtmp WHERE a <= '121.111.63.82'; + +SELECT count(*) FROM cidrtmp WHERE a = '121.111.63.82'; + +SELECT count(*) FROM cidrtmp WHERE a >= '121.111.63.82'; + +SELECT count(*) FROM cidrtmp WHERE a > '121.111.63.82'; + +CREATE INDEX cidridx ON cidrtmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM cidrtmp WHERE a < '121.111.63.82'::cidr; + +SELECT count(*) FROM cidrtmp WHERE a <= '121.111.63.82'::cidr; + +SELECT count(*) FROM cidrtmp WHERE a = '121.111.63.82'::cidr; + +SELECT count(*) FROM cidrtmp WHERE a >= '121.111.63.82'::cidr; + +SELECT count(*) FROM cidrtmp WHERE a > '121.111.63.82'::cidr; diff --git a/contrib/btree_gist/sql/date.sql b/contrib/btree_gist/sql/date.sql new file mode 100644 index 0000000..f969ef0 --- /dev/null +++ b/contrib/btree_gist/sql/date.sql @@ -0,0 +1,37 @@ +-- date check + +CREATE TABLE datetmp (a date); + +\copy datetmp from 'data/date.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM datetmp WHERE a < '2001-02-13'; + +SELECT count(*) FROM datetmp WHERE a <= '2001-02-13'; + +SELECT count(*) FROM datetmp WHERE a = '2001-02-13'; + +SELECT count(*) FROM datetmp WHERE a >= '2001-02-13'; + +SELECT count(*) FROM datetmp WHERE a > '2001-02-13'; + +SELECT a, a <-> '2001-02-13' FROM datetmp ORDER BY a <-> '2001-02-13' LIMIT 3; + +CREATE INDEX dateidx ON datetmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM datetmp WHERE a < '2001-02-13'::date; + +SELECT count(*) FROM datetmp WHERE a <= '2001-02-13'::date; + +SELECT count(*) FROM datetmp WHERE a = '2001-02-13'::date; + +SELECT count(*) FROM datetmp WHERE a >= '2001-02-13'::date; + +SELECT count(*) FROM datetmp WHERE a > '2001-02-13'::date; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '2001-02-13' FROM datetmp ORDER BY a <-> '2001-02-13' LIMIT 3; +SELECT a, a <-> '2001-02-13' FROM datetmp ORDER BY a <-> '2001-02-13' LIMIT 3; diff --git a/contrib/btree_gist/sql/enum.sql b/contrib/btree_gist/sql/enum.sql new file mode 100644 index 0000000..476211e --- /dev/null +++ b/contrib/btree_gist/sql/enum.sql @@ -0,0 +1,38 @@ +-- enum check + +create type rainbow as enum ('r','o','y','g','b','i','v'); + +CREATE TABLE enumtmp (a rainbow); + +\copy enumtmp from 'data/enum.data' + +SET enable_seqscan=on; + +select a, count(*) from enumtmp group by a order by 1; + +SELECT count(*) FROM enumtmp WHERE a < 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a <= 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a = 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a >= 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a > 'g'::rainbow; + +CREATE INDEX enumidx ON enumtmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM enumtmp WHERE a < 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a <= 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a = 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a >= 'g'::rainbow; + +SELECT count(*) FROM enumtmp WHERE a > 'g'::rainbow; + +EXPLAIN (COSTS OFF) +SELECT count(*) FROM enumtmp WHERE a >= 'g'::rainbow; diff --git a/contrib/btree_gist/sql/float4.sql b/contrib/btree_gist/sql/float4.sql new file mode 100644 index 0000000..3da1ce9 --- /dev/null +++ b/contrib/btree_gist/sql/float4.sql @@ -0,0 +1,37 @@ +-- float4 check + +CREATE TABLE float4tmp (a float4); + +\copy float4tmp from 'data/float4.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM float4tmp WHERE a < -179.0; + +SELECT count(*) FROM float4tmp WHERE a <= -179.0; + +SELECT count(*) FROM float4tmp WHERE a = -179.0; + +SELECT count(*) FROM float4tmp WHERE a >= -179.0; + +SELECT count(*) FROM float4tmp WHERE a > -179.0; + +SELECT a, a <-> '-179.0' FROM float4tmp ORDER BY a <-> '-179.0' LIMIT 3; + +CREATE INDEX float4idx ON float4tmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM float4tmp WHERE a < -179.0::float4; + +SELECT count(*) FROM float4tmp WHERE a <= -179.0::float4; + +SELECT count(*) FROM float4tmp WHERE a = -179.0::float4; + +SELECT count(*) FROM float4tmp WHERE a >= -179.0::float4; + +SELECT count(*) FROM float4tmp WHERE a > -179.0::float4; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '-179.0' FROM float4tmp ORDER BY a <-> '-179.0' LIMIT 3; +SELECT a, a <-> '-179.0' FROM float4tmp ORDER BY a <-> '-179.0' LIMIT 3; diff --git a/contrib/btree_gist/sql/float8.sql b/contrib/btree_gist/sql/float8.sql new file mode 100644 index 0000000..e1e819b --- /dev/null +++ b/contrib/btree_gist/sql/float8.sql @@ -0,0 +1,37 @@ +-- float8 check + +CREATE TABLE float8tmp (a float8); + +\copy float8tmp from 'data/float8.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM float8tmp WHERE a < -1890.0; + +SELECT count(*) FROM float8tmp WHERE a <= -1890.0; + +SELECT count(*) FROM float8tmp WHERE a = -1890.0; + +SELECT count(*) FROM float8tmp WHERE a >= -1890.0; + +SELECT count(*) FROM float8tmp WHERE a > -1890.0; + +SELECT a, a <-> '-1890.0' FROM float8tmp ORDER BY a <-> '-1890.0' LIMIT 3; + +CREATE INDEX float8idx ON float8tmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM float8tmp WHERE a < -1890.0::float8; + +SELECT count(*) FROM float8tmp WHERE a <= -1890.0::float8; + +SELECT count(*) FROM float8tmp WHERE a = -1890.0::float8; + +SELECT count(*) FROM float8tmp WHERE a >= -1890.0::float8; + +SELECT count(*) FROM float8tmp WHERE a > -1890.0::float8; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '-1890.0' FROM float8tmp ORDER BY a <-> '-1890.0' LIMIT 3; +SELECT a, a <-> '-1890.0' FROM float8tmp ORDER BY a <-> '-1890.0' LIMIT 3; diff --git a/contrib/btree_gist/sql/inet.sql b/contrib/btree_gist/sql/inet.sql new file mode 100644 index 0000000..249e808 --- /dev/null +++ b/contrib/btree_gist/sql/inet.sql @@ -0,0 +1,49 @@ +-- inet check + +CREATE TABLE inettmp (a inet); + +\copy inettmp from 'data/inet.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM inettmp WHERE a < '89.225.196.191'; + +SELECT count(*) FROM inettmp WHERE a <= '89.225.196.191'; + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'; + +SELECT count(*) FROM inettmp WHERE a >= '89.225.196.191'; + +SELECT count(*) FROM inettmp WHERE a > '89.225.196.191'; + +CREATE INDEX inetidx ON inettmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM inettmp WHERE a < '89.225.196.191'::inet; + +SELECT count(*) FROM inettmp WHERE a <= '89.225.196.191'::inet; + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + +SELECT count(*) FROM inettmp WHERE a >= '89.225.196.191'::inet; + +SELECT count(*) FROM inettmp WHERE a > '89.225.196.191'::inet; + +VACUUM ANALYZE inettmp; + +-- gist_inet_ops lacks a fetch function, so this should not be index-only scan +EXPLAIN (COSTS OFF) +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + +DROP INDEX inetidx; + +CREATE INDEX ON inettmp USING gist (a gist_inet_ops, a inet_ops); + +-- this can be an index-only scan, as long as the planner uses the right column +EXPLAIN (COSTS OFF) +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; + +SELECT count(*) FROM inettmp WHERE a = '89.225.196.191'::inet; diff --git a/contrib/btree_gist/sql/init.sql b/contrib/btree_gist/sql/init.sql new file mode 100644 index 0000000..a6d2cff --- /dev/null +++ b/contrib/btree_gist/sql/init.sql @@ -0,0 +1,6 @@ +CREATE EXTENSION btree_gist; + +-- Check whether any of our opclasses fail amvalidate +SELECT amname, opcname +FROM pg_opclass opc LEFT JOIN pg_am am ON am.oid = opcmethod +WHERE opc.oid >= 16384 AND NOT amvalidate(opc.oid); diff --git a/contrib/btree_gist/sql/int2.sql b/contrib/btree_gist/sql/int2.sql new file mode 100644 index 0000000..9885187 --- /dev/null +++ b/contrib/btree_gist/sql/int2.sql @@ -0,0 +1,37 @@ +-- int2 check + +CREATE TABLE int2tmp (a int2); + +\copy int2tmp from 'data/int2.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM int2tmp WHERE a < 237; + +SELECT count(*) FROM int2tmp WHERE a <= 237; + +SELECT count(*) FROM int2tmp WHERE a = 237; + +SELECT count(*) FROM int2tmp WHERE a >= 237; + +SELECT count(*) FROM int2tmp WHERE a > 237; + +SELECT a, a <-> '237' FROM int2tmp ORDER BY a <-> '237' LIMIT 3; + +CREATE INDEX int2idx ON int2tmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM int2tmp WHERE a < 237::int2; + +SELECT count(*) FROM int2tmp WHERE a <= 237::int2; + +SELECT count(*) FROM int2tmp WHERE a = 237::int2; + +SELECT count(*) FROM int2tmp WHERE a >= 237::int2; + +SELECT count(*) FROM int2tmp WHERE a > 237::int2; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '237' FROM int2tmp ORDER BY a <-> '237' LIMIT 3; +SELECT a, a <-> '237' FROM int2tmp ORDER BY a <-> '237' LIMIT 3; diff --git a/contrib/btree_gist/sql/int4.sql b/contrib/btree_gist/sql/int4.sql new file mode 100644 index 0000000..659ab5e --- /dev/null +++ b/contrib/btree_gist/sql/int4.sql @@ -0,0 +1,37 @@ +-- int4 check + +CREATE TABLE int4tmp (a int4); + +\copy int4tmp from 'data/int2.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM int4tmp WHERE a < 237; + +SELECT count(*) FROM int4tmp WHERE a <= 237; + +SELECT count(*) FROM int4tmp WHERE a = 237; + +SELECT count(*) FROM int4tmp WHERE a >= 237; + +SELECT count(*) FROM int4tmp WHERE a > 237; + +SELECT a, a <-> '237' FROM int4tmp ORDER BY a <-> '237' LIMIT 3; + +CREATE INDEX int4idx ON int4tmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM int4tmp WHERE a < 237::int4; + +SELECT count(*) FROM int4tmp WHERE a <= 237::int4; + +SELECT count(*) FROM int4tmp WHERE a = 237::int4; + +SELECT count(*) FROM int4tmp WHERE a >= 237::int4; + +SELECT count(*) FROM int4tmp WHERE a > 237::int4; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '237' FROM int4tmp ORDER BY a <-> '237' LIMIT 3; +SELECT a, a <-> '237' FROM int4tmp ORDER BY a <-> '237' LIMIT 3; diff --git a/contrib/btree_gist/sql/int8.sql b/contrib/btree_gist/sql/int8.sql new file mode 100644 index 0000000..51e55e9 --- /dev/null +++ b/contrib/btree_gist/sql/int8.sql @@ -0,0 +1,37 @@ +-- int8 check + +CREATE TABLE int8tmp (a int8); + +\copy int8tmp from 'data/int8.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM int8tmp WHERE a < 464571291354841; + +SELECT count(*) FROM int8tmp WHERE a <= 464571291354841; + +SELECT count(*) FROM int8tmp WHERE a = 464571291354841; + +SELECT count(*) FROM int8tmp WHERE a >= 464571291354841; + +SELECT count(*) FROM int8tmp WHERE a > 464571291354841; + +SELECT a, a <-> '464571291354841' FROM int8tmp ORDER BY a <-> '464571291354841' LIMIT 3; + +CREATE INDEX int8idx ON int8tmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM int8tmp WHERE a < 464571291354841::int8; + +SELECT count(*) FROM int8tmp WHERE a <= 464571291354841::int8; + +SELECT count(*) FROM int8tmp WHERE a = 464571291354841::int8; + +SELECT count(*) FROM int8tmp WHERE a >= 464571291354841::int8; + +SELECT count(*) FROM int8tmp WHERE a > 464571291354841::int8; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '464571291354841' FROM int8tmp ORDER BY a <-> '464571291354841' LIMIT 3; +SELECT a, a <-> '464571291354841' FROM int8tmp ORDER BY a <-> '464571291354841' LIMIT 3; diff --git a/contrib/btree_gist/sql/interval.sql b/contrib/btree_gist/sql/interval.sql new file mode 100644 index 0000000..346d6ad --- /dev/null +++ b/contrib/btree_gist/sql/interval.sql @@ -0,0 +1,43 @@ +-- interval check + +CREATE TABLE intervaltmp (a interval); + +\copy intervaltmp from 'data/interval.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM intervaltmp WHERE a < '199 days 21:21:23'; + +SELECT count(*) FROM intervaltmp WHERE a <= '199 days 21:21:23'; + +SELECT count(*) FROM intervaltmp WHERE a = '199 days 21:21:23'; + +SELECT count(*) FROM intervaltmp WHERE a >= '199 days 21:21:23'; + +SELECT count(*) FROM intervaltmp WHERE a > '199 days 21:21:23'; + +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; + +CREATE INDEX intervalidx ON intervaltmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM intervaltmp WHERE a < '199 days 21:21:23'::interval; + +SELECT count(*) FROM intervaltmp WHERE a <= '199 days 21:21:23'::interval; + +SELECT count(*) FROM intervaltmp WHERE a = '199 days 21:21:23'::interval; + +SELECT count(*) FROM intervaltmp WHERE a >= '199 days 21:21:23'::interval; + +SELECT count(*) FROM intervaltmp WHERE a > '199 days 21:21:23'::interval; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; + +SET enable_indexonlyscan=off; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; +SELECT a, a <-> '199 days 21:21:23' FROM intervaltmp ORDER BY a <-> '199 days 21:21:23' LIMIT 3; diff --git a/contrib/btree_gist/sql/macaddr.sql b/contrib/btree_gist/sql/macaddr.sql new file mode 100644 index 0000000..85c271f --- /dev/null +++ b/contrib/btree_gist/sql/macaddr.sql @@ -0,0 +1,37 @@ +-- macaddr check + +CREATE TABLE macaddrtmp (a macaddr); + +\copy macaddrtmp from 'data/macaddr.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM macaddrtmp WHERE a < '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddrtmp WHERE a <= '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddrtmp WHERE a = '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddrtmp WHERE a >= '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddrtmp WHERE a > '22:00:5c:e5:9b:0d'; + +CREATE INDEX macaddridx ON macaddrtmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM macaddrtmp WHERE a < '22:00:5c:e5:9b:0d'::macaddr; + +SELECT count(*) FROM macaddrtmp WHERE a <= '22:00:5c:e5:9b:0d'::macaddr; + +SELECT count(*) FROM macaddrtmp WHERE a = '22:00:5c:e5:9b:0d'::macaddr; + +SELECT count(*) FROM macaddrtmp WHERE a >= '22:00:5c:e5:9b:0d'::macaddr; + +SELECT count(*) FROM macaddrtmp WHERE a > '22:00:5c:e5:9b:0d'::macaddr; + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM macaddrtmp WHERE a < '02:03:04:05:06:07'::macaddr; +SELECT * FROM macaddrtmp WHERE a < '02:03:04:05:06:07'::macaddr; diff --git a/contrib/btree_gist/sql/macaddr8.sql b/contrib/btree_gist/sql/macaddr8.sql new file mode 100644 index 0000000..61e7d7a --- /dev/null +++ b/contrib/btree_gist/sql/macaddr8.sql @@ -0,0 +1,37 @@ +-- macaddr check + +CREATE TABLE macaddr8tmp (a macaddr8); + +\copy macaddr8tmp from 'data/macaddr.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM macaddr8tmp WHERE a < '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddr8tmp WHERE a <= '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddr8tmp WHERE a = '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddr8tmp WHERE a >= '22:00:5c:e5:9b:0d'; + +SELECT count(*) FROM macaddr8tmp WHERE a > '22:00:5c:e5:9b:0d'; + +CREATE INDEX macaddr8idx ON macaddr8tmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM macaddr8tmp WHERE a < '22:00:5c:e5:9b:0d'::macaddr8; + +SELECT count(*) FROM macaddr8tmp WHERE a <= '22:00:5c:e5:9b:0d'::macaddr8; + +SELECT count(*) FROM macaddr8tmp WHERE a = '22:00:5c:e5:9b:0d'::macaddr8; + +SELECT count(*) FROM macaddr8tmp WHERE a >= '22:00:5c:e5:9b:0d'::macaddr8; + +SELECT count(*) FROM macaddr8tmp WHERE a > '22:00:5c:e5:9b:0d'::macaddr8; + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM macaddr8tmp WHERE a < '02:03:04:05:06:07'::macaddr8; +SELECT * FROM macaddr8tmp WHERE a < '02:03:04:05:06:07'::macaddr8; diff --git a/contrib/btree_gist/sql/not_equal.sql b/contrib/btree_gist/sql/not_equal.sql new file mode 100644 index 0000000..6dfac5d --- /dev/null +++ b/contrib/btree_gist/sql/not_equal.sql @@ -0,0 +1,36 @@ + +SET enable_seqscan to false; + +-- test search for "not equals" + +CREATE TABLE test_ne ( + a TIMESTAMP, + b NUMERIC +); +CREATE INDEX test_ne_idx ON test_ne USING gist (a, b); + +INSERT INTO test_ne SELECT '2009-01-01', 10.7 FROM generate_series(1,1000); +INSERT INTO test_ne VALUES('2007-02-03', -91.3); +INSERT INTO test_ne VALUES('2011-09-01', 43.7); +INSERT INTO test_ne SELECT '2009-01-01', 10.7 FROM generate_series(1,1000); + +SET enable_indexscan to false; + +EXPLAIN (COSTS OFF) SELECT * FROM test_ne WHERE a <> '2009-01-01' AND b <> 10.7; + +SELECT * FROM test_ne WHERE a <> '2009-01-01' AND b <> 10.7; + +RESET enable_indexscan; + +-- test search for "not equals" using an exclusion constraint + +CREATE TABLE zoo ( + cage INTEGER, + animal TEXT, + EXCLUDE USING gist (cage WITH =, animal WITH <>) +); + +INSERT INTO zoo VALUES(123, 'zebra'); +INSERT INTO zoo VALUES(123, 'zebra'); +INSERT INTO zoo VALUES(123, 'lion'); +INSERT INTO zoo VALUES(124, 'lion'); diff --git a/contrib/btree_gist/sql/numeric.sql b/contrib/btree_gist/sql/numeric.sql new file mode 100644 index 0000000..dbb2f2f --- /dev/null +++ b/contrib/btree_gist/sql/numeric.sql @@ -0,0 +1,83 @@ +-- numeric check + +CREATE TABLE numerictmp (a numeric); + +\copy numerictmp from 'data/int8.data' +\copy numerictmp from 'data/numeric.data' +\copy numerictmp from 'data/float8.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM numerictmp WHERE a < -1890.0; + +SELECT count(*) FROM numerictmp WHERE a <= -1890.0; + +SELECT count(*) FROM numerictmp WHERE a = -1890.0; + +SELECT count(*) FROM numerictmp WHERE a >= -1890.0; + +SELECT count(*) FROM numerictmp WHERE a > -1890.0; + + +SELECT count(*) FROM numerictmp WHERE a < 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a <= 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a = 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a >= 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a > 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a < 0 ; + +SELECT count(*) FROM numerictmp WHERE a <= 0 ; + +SELECT count(*) FROM numerictmp WHERE a = 0 ; + +SELECT count(*) FROM numerictmp WHERE a >= 0 ; + +SELECT count(*) FROM numerictmp WHERE a > 0 ; + + +CREATE INDEX numericidx ON numerictmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM numerictmp WHERE a < -1890.0; + +SELECT count(*) FROM numerictmp WHERE a <= -1890.0; + +SELECT count(*) FROM numerictmp WHERE a = -1890.0; + +SELECT count(*) FROM numerictmp WHERE a >= -1890.0; + +SELECT count(*) FROM numerictmp WHERE a > -1890.0; + + +SELECT count(*) FROM numerictmp WHERE a < 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a <= 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a = 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a >= 'NaN' ; + +SELECT count(*) FROM numerictmp WHERE a > 'NaN' ; + + +SELECT count(*) FROM numerictmp WHERE a < 0 ; + +SELECT count(*) FROM numerictmp WHERE a <= 0 ; + +SELECT count(*) FROM numerictmp WHERE a = 0 ; + +SELECT count(*) FROM numerictmp WHERE a >= 0 ; + +SELECT count(*) FROM numerictmp WHERE a > 0 ; + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM numerictmp WHERE a BETWEEN 1 AND 300 ORDER BY a; +SELECT * FROM numerictmp WHERE a BETWEEN 1 AND 300 ORDER BY a; diff --git a/contrib/btree_gist/sql/oid.sql b/contrib/btree_gist/sql/oid.sql new file mode 100644 index 0000000..c935823 --- /dev/null +++ b/contrib/btree_gist/sql/oid.sql @@ -0,0 +1,30 @@ +-- oid check + +SET enable_seqscan=on; + +CREATE TEMPORARY TABLE oidtmp (oid oid); +INSERT INTO oidtmp SELECT g.i::oid FROM generate_series(1, 1000) g(i); + +SELECT count(*) FROM oidtmp WHERE oid < 17; + +SELECT count(*) FROM oidtmp WHERE oid <= 17; + +SELECT count(*) FROM oidtmp WHERE oid = 17; + +SELECT count(*) FROM oidtmp WHERE oid >= 17; + +SELECT count(*) FROM oidtmp WHERE oid > 17; + +CREATE INDEX oididx ON oidtmp USING gist ( oid ); + +SET enable_seqscan=off; + +SELECT count(*) FROM oidtmp WHERE oid < 17; + +SELECT count(*) FROM oidtmp WHERE oid <= 17; + +SELECT count(*) FROM oidtmp WHERE oid = 17; + +SELECT count(*) FROM oidtmp WHERE oid >= 17; + +SELECT count(*) FROM oidtmp WHERE oid > 17; diff --git a/contrib/btree_gist/sql/text.sql b/contrib/btree_gist/sql/text.sql new file mode 100644 index 0000000..46597e7 --- /dev/null +++ b/contrib/btree_gist/sql/text.sql @@ -0,0 +1,40 @@ +-- text check + +CREATE TABLE texttmp (a text); + +\copy texttmp from 'data/text.data' +\copy texttmp from 'data/char.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM texttmp WHERE a < '31b0'; + +SELECT count(*) FROM texttmp WHERE a <= '31b0'; + +SELECT count(*) FROM texttmp WHERE a = '31b0'; + +SELECT count(*) FROM texttmp WHERE a >= '31b0'; + +SELECT count(*) FROM texttmp WHERE a > '31b0'; + +CREATE INDEX textidx ON texttmp USING GIST ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM texttmp WHERE a < '31b0'::text; + +SELECT count(*) FROM texttmp WHERE a <= '31b0'::text; + +SELECT count(*) FROM texttmp WHERE a = '31b0'::text; + +SELECT count(*) FROM texttmp WHERE a >= '31b0'::text; + +SELECT count(*) FROM texttmp WHERE a > '31b0'::text; + +SELECT count(*) FROM texttmp WHERE a = '2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809 2eb2c961c1cbf6 cf8d7b68cb9a2f36 7bbedb4ae7 06ec46c55611a466eb7e3edcc009ca6 e 5ed9cd0ea5a4e55d601027c56a 64cacf3a42afc 90e63000c34506993345355640 79bce 173bb7 c5 574ea7c921cb0f25 089d56d16dff24f336e4740 6870470f1f9afcb4f7c56c9f b97e117fc965 7013029 e48f6dd481 7d00e1e227beef84a9 904d4c34241f cb5c0f14 3a8a70 f51a73164e92052fbb53b4cc2f1fed 3c3fecaa0270175 2521ef03594 fa05756812648f450fb 13c2f b39a0729d6182e9 15b5ea204fe73 d8991afd72d21acd188df1 a29fff57ab897338 de549b3ed5a024534c007125c 2fcf3e5c3e3 7427b6daec5c3f 473 8 a5d9 840410976ac2eeab58e1ca8bf46c2b7 1db9cc85a336f1291ea19922 db808f3548cda91 2e379ce80af12bd7ed56d0338c a ea67a7c847f6620fc894f0ba10044 0e 52e97d975af7201d8 d95e6f08184d8ff 19762476fa 42f278f3534f3f2be0abaed71 f0aba11835e4e1d94 e8534cf677046eafb8f5f761865 ffbee273c7bb 2bb77f6e780 c77e81851c491 e a9f45d765b01a030d5d317 ff7345a22bc360 c87363ba121297b063e83 13ea32e9618d 40304f6c2a7e92c1c66ff4208e a781b4a21419abfdf5eb467e4d48908 8a65656e514b2b3ef8f86310aaf85 4 90b7b2862e3dbc8f0eef3dfc6075bfa eb94a1c a58abb5def4fa43840e6e2716 260e6eaebb 42415d712bf83944dcd1204e 305254fc3b849150b5 5bbd7f8471dcd3621 2ae0548115a250 0c1988e9 76f98bef45639b7 0d5a28f01dc b71 c046576faa4d49eff8 c1e8d01c 10c86c457ea050455a742da4f8 ea7676af85c71c7eeca635 6a07137227404d a4 7186172 8150f31c9a15401c f1bb9057a9938bfa 22b482be08f424ec4 21daea994293589 15bff393f6b17fef24786dd6f9 d5a2d 4b3b5dd9370543e b4a93b2ac4341945d06 d384447812e0 4e3c97e9b8f7 f7d4d644b2a1d373 5102c b9531f725674b28 1aa16e7e34285797c1439 51aa762ea14b40fb8876c887eea6 45a62d3d5d3e946250904697486591 b3f1a8 243524767bf846d 8 95 45a922872 dd2497eb1e3da8d513d2 7821db9e14d4f 24c4f085de60d7c0c6ea3fc6bc e4c9f8c68596d7d afd6c8cb0f2516b87f24bbd8 61d2e457c70949 d2d362cdc657 3605f9d27fd6d72 32de91d66fe5bf537530 859e1a08b65 9b5a55f 4116cda9fddeb843964002 e81f3b2c0ca566ad3dbbc6e234 0d3b1d54 10c440be5c0bca95 7dad841f a61f041967972e805ccfee55c deee9cc16e92ab197 7627554073c1f56b9e 21bebcbfd2e2282f84 7b121a83eeb91db8bda81ba88c634b46394 59885ebc737617addaaf0cb809'::text; + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT * FROM texttmp WHERE a BETWEEN '31a' AND '31c'; +SELECT * FROM texttmp WHERE a BETWEEN '31a' AND '31c'; diff --git a/contrib/btree_gist/sql/time.sql b/contrib/btree_gist/sql/time.sql new file mode 100644 index 0000000..6104e7f --- /dev/null +++ b/contrib/btree_gist/sql/time.sql @@ -0,0 +1,37 @@ +-- time check + +CREATE TABLE timetmp (a time); + +\copy timetmp from 'data/time.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM timetmp WHERE a < '10:57:11'; + +SELECT count(*) FROM timetmp WHERE a <= '10:57:11'; + +SELECT count(*) FROM timetmp WHERE a = '10:57:11'; + +SELECT count(*) FROM timetmp WHERE a >= '10:57:11'; + +SELECT count(*) FROM timetmp WHERE a > '10:57:11'; + +SELECT a, a <-> '10:57:11' FROM timetmp ORDER BY a <-> '10:57:11' LIMIT 3; + +CREATE INDEX timeidx ON timetmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM timetmp WHERE a < '10:57:11'::time; + +SELECT count(*) FROM timetmp WHERE a <= '10:57:11'::time; + +SELECT count(*) FROM timetmp WHERE a = '10:57:11'::time; + +SELECT count(*) FROM timetmp WHERE a >= '10:57:11'::time; + +SELECT count(*) FROM timetmp WHERE a > '10:57:11'::time; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '10:57:11' FROM timetmp ORDER BY a <-> '10:57:11' LIMIT 3; +SELECT a, a <-> '10:57:11' FROM timetmp ORDER BY a <-> '10:57:11' LIMIT 3; diff --git a/contrib/btree_gist/sql/timestamp.sql b/contrib/btree_gist/sql/timestamp.sql new file mode 100644 index 0000000..95effeb --- /dev/null +++ b/contrib/btree_gist/sql/timestamp.sql @@ -0,0 +1,37 @@ +-- timestamp check + +CREATE TABLE timestamptmp (a timestamp); + +\copy timestamptmp from 'data/timestamp.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM timestamptmp WHERE a < '2004-10-26 08:55:08'; + +SELECT count(*) FROM timestamptmp WHERE a <= '2004-10-26 08:55:08'; + +SELECT count(*) FROM timestamptmp WHERE a = '2004-10-26 08:55:08'; + +SELECT count(*) FROM timestamptmp WHERE a >= '2004-10-26 08:55:08'; + +SELECT count(*) FROM timestamptmp WHERE a > '2004-10-26 08:55:08'; + +SELECT a, a <-> '2004-10-26 08:55:08' FROM timestamptmp ORDER BY a <-> '2004-10-26 08:55:08' LIMIT 3; + +CREATE INDEX timestampidx ON timestamptmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM timestamptmp WHERE a < '2004-10-26 08:55:08'::timestamp; + +SELECT count(*) FROM timestamptmp WHERE a <= '2004-10-26 08:55:08'::timestamp; + +SELECT count(*) FROM timestamptmp WHERE a = '2004-10-26 08:55:08'::timestamp; + +SELECT count(*) FROM timestamptmp WHERE a >= '2004-10-26 08:55:08'::timestamp; + +SELECT count(*) FROM timestamptmp WHERE a > '2004-10-26 08:55:08'::timestamp; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '2004-10-26 08:55:08' FROM timestamptmp ORDER BY a <-> '2004-10-26 08:55:08' LIMIT 3; +SELECT a, a <-> '2004-10-26 08:55:08' FROM timestamptmp ORDER BY a <-> '2004-10-26 08:55:08' LIMIT 3; diff --git a/contrib/btree_gist/sql/timestamptz.sql b/contrib/btree_gist/sql/timestamptz.sql new file mode 100644 index 0000000..f70caa4 --- /dev/null +++ b/contrib/btree_gist/sql/timestamptz.sql @@ -0,0 +1,80 @@ +-- timestamptz check + +CREATE TABLE timestamptztmp (a timestamptz); + +\copy timestamptztmp from 'data/timestamptz.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+3'; + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+3'; + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+3'; + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+3'; + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+3'; + + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+2'; + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+2'; + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+2'; + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+2'; + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+2'; + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+4'; + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+4'; + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+4'; + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+4'; + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+4'; + +SELECT a, a <-> '2018-12-18 10:59:54 GMT+2' FROM timestamptztmp ORDER BY a <-> '2018-12-18 10:59:54 GMT+2' LIMIT 3; + +CREATE INDEX timestamptzidx ON timestamptztmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+3'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+3'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+3'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+3'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+3'::timestamptz; + + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+2'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+2'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+2'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+2'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+2'::timestamptz; + + +SELECT count(*) FROM timestamptztmp WHERE a < '2018-12-18 10:59:54 GMT+4'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+4'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a = '2018-12-18 10:59:54 GMT+4'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a >= '2018-12-18 10:59:54 GMT+4'::timestamptz; + +SELECT count(*) FROM timestamptztmp WHERE a > '2018-12-18 10:59:54 GMT+4'::timestamptz; + +EXPLAIN (COSTS OFF) +SELECT a, a <-> '2018-12-18 10:59:54 GMT+2' FROM timestamptztmp ORDER BY a <-> '2018-12-18 10:59:54 GMT+2' LIMIT 3; +SELECT a, a <-> '2018-12-18 10:59:54 GMT+2' FROM timestamptztmp ORDER BY a <-> '2018-12-18 10:59:54 GMT+2' LIMIT 3; diff --git a/contrib/btree_gist/sql/timetz.sql b/contrib/btree_gist/sql/timetz.sql new file mode 100644 index 0000000..2fb725d --- /dev/null +++ b/contrib/btree_gist/sql/timetz.sql @@ -0,0 +1,82 @@ +-- timetz check + +CREATE TABLE timetztmp (a timetz); +\copy timetztmp from 'data/timetz.data' + +CREATE TABLE timetzcmp ( r_id int2, a int4, b int4 ); + + +SET enable_seqscan=on; + +INSERT INTO timetzcmp (r_id,a) SELECT 1,count(*) FROM timetztmp WHERE a < '07:46:45 GMT+3'; + +INSERT INTO timetzcmp (r_id,a) SELECT 2,count(*) FROM timetztmp WHERE a <= '07:46:45 GMT+3'; + +INSERT INTO timetzcmp (r_id,a) SELECT 3,count(*) FROM timetztmp WHERE a = '07:46:45 GMT+3'; + +INSERT INTO timetzcmp (r_id,a) SELECT 4,count(*) FROM timetztmp WHERE a >= '07:46:45 GMT+3'; + +INSERT INTO timetzcmp (r_id,a) SELECT 5,count(*) FROM timetztmp WHERE a > '07:46:45 GMT+3'; + + +INSERT INTO timetzcmp (r_id,a) SELECT 11,count(*) FROM timetztmp WHERE a < '07:46:45 GMT+2'; + +INSERT INTO timetzcmp (r_id,a) SELECT 12,count(*) FROM timetztmp WHERE a <= '07:46:45 GMT+2'; + +INSERT INTO timetzcmp (r_id,a) SELECT 13,count(*) FROM timetztmp WHERE a = '07:46:45 GMT+2'; + +INSERT INTO timetzcmp (r_id,a) SELECT 14,count(*) FROM timetztmp WHERE a >= '07:46:45 GMT+2'; + +INSERT INTO timetzcmp (r_id,a) SELECT 15,count(*) FROM timetztmp WHERE a > '07:46:45 GMT+2'; + + +INSERT INTO timetzcmp (r_id,a) SELECT 21,count(*) FROM timetztmp WHERE a < '07:46:45 GMT+4'; + +INSERT INTO timetzcmp (r_id,a) SELECT 22,count(*) FROM timetztmp WHERE a <= '07:46:45 GMT+4'; + +INSERT INTO timetzcmp (r_id,a) SELECT 23,count(*) FROM timetztmp WHERE a = '07:46:45 GMT+4'; + +INSERT INTO timetzcmp (r_id,a) SELECT 24,count(*) FROM timetztmp WHERE a >= '07:46:45 GMT+4'; + +INSERT INTO timetzcmp (r_id,a) SELECT 25,count(*) FROM timetztmp WHERE a > '07:46:45 GMT+4'; + + + +CREATE INDEX timetzidx ON timetztmp USING gist ( a ); + +SET enable_seqscan=off; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a < '07:46:45 GMT+3'::timetz ) q WHERE r_id=1 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a <= '07:46:45 GMT+3'::timetz ) q WHERE r_id=2 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a = '07:46:45 GMT+3'::timetz ) q WHERE r_id=3 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a >= '07:46:45 GMT+3'::timetz ) q WHERE r_id=4 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a > '07:46:45 GMT+3'::timetz ) q WHERE r_id=5 ; + + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a < '07:46:45 GMT+2'::timetz ) q WHERE r_id=11 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a <= '07:46:45 GMT+2'::timetz ) q WHERE r_id=12 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a = '07:46:45 GMT+2'::timetz ) q WHERE r_id=13 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a >= '07:46:45 GMT+2'::timetz ) q WHERE r_id=14 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a > '07:46:45 GMT+2'::timetz ) q WHERE r_id=15 ; + + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a < '07:46:45 GMT+4'::timetz ) q WHERE r_id=21 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a <= '07:46:45 GMT+4'::timetz ) q WHERE r_id=22 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a = '07:46:45 GMT+4'::timetz ) q WHERE r_id=23 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a >= '07:46:45 GMT+4'::timetz ) q WHERE r_id=24 ; + +UPDATE timetzcmp SET b=c FROM ( SELECT count(*) AS c FROM timetztmp WHERE a > '07:46:45 GMT+4'::timetz ) q WHERE r_id=25 ; + + +SELECT count(*) FROM timetzcmp WHERE a=b; diff --git a/contrib/btree_gist/sql/uuid.sql b/contrib/btree_gist/sql/uuid.sql new file mode 100644 index 0000000..3f7ad76 --- /dev/null +++ b/contrib/btree_gist/sql/uuid.sql @@ -0,0 +1,31 @@ +-- uuid check + +CREATE TABLE uuidtmp (a uuid); + +\copy uuidtmp from 'data/uuid.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM uuidtmp WHERE a < '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + +SELECT count(*) FROM uuidtmp WHERE a <= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + +SELECT count(*) FROM uuidtmp WHERE a = '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + +SELECT count(*) FROM uuidtmp WHERE a >= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + +SELECT count(*) FROM uuidtmp WHERE a > '55e65ca2-4136-4a4b-ba78-cd3fe4678203'; + +CREATE INDEX uuididx ON uuidtmp USING gist ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM uuidtmp WHERE a < '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + +SELECT count(*) FROM uuidtmp WHERE a <= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + +SELECT count(*) FROM uuidtmp WHERE a = '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + +SELECT count(*) FROM uuidtmp WHERE a >= '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; + +SELECT count(*) FROM uuidtmp WHERE a > '55e65ca2-4136-4a4b-ba78-cd3fe4678203'::uuid; diff --git a/contrib/btree_gist/sql/varbit.sql b/contrib/btree_gist/sql/varbit.sql new file mode 100644 index 0000000..e2a33b5 --- /dev/null +++ b/contrib/btree_gist/sql/varbit.sql @@ -0,0 +1,36 @@ +-- varbit check + +CREATE TABLE varbittmp (a varbit); + +\copy varbittmp from 'data/varbit.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM varbittmp WHERE a < '1110100111010'; + +SELECT count(*) FROM varbittmp WHERE a <= '1110100111010'; + +SELECT count(*) FROM varbittmp WHERE a = '1110100111010'; + +SELECT count(*) FROM varbittmp WHERE a >= '1110100111010'; + +SELECT count(*) FROM varbittmp WHERE a > '1110100111010'; + +CREATE INDEX varbitidx ON varbittmp USING GIST ( a ); + +SET enable_seqscan=off; + +SELECT count(*) FROM varbittmp WHERE a < '1110100111010'::varbit; + +SELECT count(*) FROM varbittmp WHERE a <= '1110100111010'::varbit; + +SELECT count(*) FROM varbittmp WHERE a = '1110100111010'::varbit; + +SELECT count(*) FROM varbittmp WHERE a >= '1110100111010'::varbit; + +SELECT count(*) FROM varbittmp WHERE a > '1110100111010'::varbit; + +-- Test index-only scans +SET enable_bitmapscan=off; +EXPLAIN (COSTS OFF) +SELECT a FROM bittmp WHERE a BETWEEN '1000000' and '1000001'; diff --git a/contrib/btree_gist/sql/varchar.sql b/contrib/btree_gist/sql/varchar.sql new file mode 100644 index 0000000..8087a17 --- /dev/null +++ b/contrib/btree_gist/sql/varchar.sql @@ -0,0 +1,31 @@ +-- char check + +CREATE TABLE vchartmp (a varchar(32)); + +\copy vchartmp from 'data/char.data' + +SET enable_seqscan=on; + +SELECT count(*) FROM vchartmp WHERE a < '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a <= '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a = '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a >= '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a > '31b0'::varchar(32); + +CREATE INDEX vcharidx ON vchartmp USING GIST ( text(a) ); + +SET enable_seqscan=off; + +SELECT count(*) FROM vchartmp WHERE a < '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a <= '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a = '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a >= '31b0'::varchar(32); + +SELECT count(*) FROM vchartmp WHERE a > '31b0'::varchar(32); |