New version. Add support for int2, int8, float4, float8, timestamp with/without time zone, time with/without time zone, date, interval, oid, money and macaddr, char, varchar/text, bytea, numeric, bit, varbit, inet/cidr types for GiST

contrib/btree_gist/Makefile

@@ -3,27 +3,17 @@ subdir = contrib/btree_gist
 top_builddir = ../..
 include $(top_builddir)/src/Makefile.global
 
-MODULE_big = btree_gist
+MODULE_big  = btree_gist
-OBJS= btree_common.o btree_int2.o btree_int4.o btree_int8.o btree_float4.o btree_float8.o btree_ts.o
-DATA_built = btree_gist.sql
-DOCS = README.btree_gist
-REGRESS = btree_gist
 
-EXTRA_CLEAN = btree_int2.c btree_int4.c btree_int8.c btree_float4.c btree_float8.c 
+OBJS        = btree_gist.o btree_utils_num.o btree_utils_var.o btree_int2.o btree_int4.o btree_int8.o \
+              btree_float4.o btree_float8.o btree_cash.o btree_oid.o btree_ts.o btree_time.o \
+              btree_date.o btree_interval.o btree_macaddr.o btree_inet.o btree_text.o \
+              btree_bytea.o btree_bit.o btree_numeric.o
+
+DATA_built  = btree_gist.sql
+DOCS        = README.btree_gist
+
+REGRESS     = init int2 int4 int8 float4 float8 cash oid timestamp timestamptz time timetz \
+              date interval macaddr inet cidr text varchar char bytea bit varbit numeric
 
 include $(top_srcdir)/contrib/contrib-global.mk
-
-btree_int2.c: btree_num.c.in
-	sed 's,__DEFINE_BTREE_TYPE_HERE__,BTREE_GIST_INT2,g;s,__BTREE_GIST_TYPE__,int16,g;s,__BTREE_GIST_TYPE2__,int2,g' < $<  > $@
-
-btree_int4.c: btree_num.c.in
-	sed 's,__DEFINE_BTREE_TYPE_HERE__,BTREE_GIST_INT4,g;s,__BTREE_GIST_TYPE__,int32,g;s,__BTREE_GIST_TYPE2__,int4,g' < $<  > $@
-
-btree_int8.c: btree_num.c.in
-	sed 's,__DEFINE_BTREE_TYPE_HERE__,BTREE_GIST_INT8,g;s,__BTREE_GIST_TYPE__,int64,g;s,__BTREE_GIST_TYPE2__,int8,g' < $<  > $@
-
-btree_float4.c: btree_num.c.in
-	sed 's,__DEFINE_BTREE_TYPE_HERE__,BTREE_GIST_FLOAT4,g;s,__BTREE_GIST_TYPE__,float4,g;s,__BTREE_GIST_TYPE2__,float4,g' < $<  > $@
-
-btree_float8.c: btree_num.c.in
-	sed 's,__DEFINE_BTREE_TYPE_HERE__,BTREE_GIST_FLOAT8,g;s,__BTREE_GIST_TYPE__,float8,g;s,__BTREE_GIST_TYPE2__,float8,g' < $<  > $@

contrib/btree_gist/README.btree_gist

@@ -1,19 +1,38 @@
 This is B-Tree implementation using GiST for int2, int4, int8, float4, float8
-timestamp types.
+timestamp with/without time zone, time with/without time zone, date,
+interval, oid, money and macaddr, char, varchar/text, bytea, numeric,
+bit, varbit, inet/cidr types.
 
-All work was done by Teodor Sigaev (teodor@stack.net) and Oleg Bartunov
+All work was done by Teodor Sigaev (teodor@stack.net) , Oleg Bartunov
-(oleg@sai.msu.su). See http://www.sai.msu.su/~megera/postgres/gist
+(oleg@sai.msu.su), Janko Richter (jankorichter@yahoo.de).
-for additional information.
+See http://www.sai.msu.su/~megera/postgres/gist for additional
+information.
 
 NEWS:
-     Feb 5, 2003 - btree_gist now support int2, int8, float4, float8 !
+
-                   Thank Janko Richter <jankorichter@yahoo.de> for
+     Apr 17, 2004 - Performance optimizing
-                   contribution.
+
+     Jan 21, 2004 - add support for bytea, numeric, bit, varbit, inet/cidr
+
+     Jan 17, 2004 - Reorganizing code and add support for char, varchar/text
+
+     Jan 10, 2004 - btree_gist now support oid , timestamp with time zone ,
+                    time with and without time zone, date , interval
+                    money, macaddr
+
+     Feb  5, 2003 - btree_gist now support int2, int8, float4, float8
      
 NOTICE:
-     This version will works only with postgresql version 7.3 and above
+     This version will works only with postgresql version 7.4 and above
      because of changes in interface of function calling and in system
      tables.
+     
+     If you want to index varchar attributes, you have to index using
+     the function text(<varchar>):
+     Example:
+       CREATE TABLE test ( a varchar(23) );
+       CREATE INDEX testidx ON test USING GIST ( text(a) );
+
 
 INSTALLATION:
 

contrib/btree_gist/btree_bit.c

@@ -0,0 +1,185 @@
+#include "btree_gist.h"
+#include "btree_utils_var.h"
+#include "utils/builtins.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);
+
+Datum    gbt_bit_compress(PG_FUNCTION_ARGS);
+Datum    gbt_bit_union(PG_FUNCTION_ARGS);
+Datum    gbt_bit_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_bit_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_bit_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_bit_same(PG_FUNCTION_ARGS);
+
+
+
+/* define for comparison */
+
+static bool     gbt_bitgt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( bitgt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_bitge     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( bitge ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_biteq     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( biteq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_bitle     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( bitle ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_bitlt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( bitlt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static int32 gbt_bitcmp ( const bytea * a , const bytea * b )
+{
+  return
+    ( DatumGetInt32(DirectFunctionCall2(byteacmp,PointerGetDatum(a),PointerGetDatum(b) ) ) );
+}
+ 
+
+static bytea *
+gbt_bit_xfrm ( bytea * leaf )
+{
+    bytea  * out = leaf;
+    int        s = VARBITBYTES(leaf) + VARHDRSZ;
+
+    out  = palloc ( s );
+    VARATT_SIZEP(out) = s;
+    memcpy ( (void*)VARDATA(out), (void*)VARBITS(leaf), VARBITBYTES(leaf) );
+    return out;
+}
+
+
+
+
+static GBT_VARKEY * gbt_bit_l2n ( GBT_VARKEY * leaf )
+{
+
+  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, TRUE );
+  pfree(o);
+
+  return out;
+
+}
+
+static const gbtree_vinfo tinfo =
+{
+  gbt_t_bit,
+  FALSE,
+  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);
+  GBT_VARKEY       *ktst  = (GBT_VARKEY   *) DatumGetPointer ( entry->key ) ;
+  GBT_VARKEY        *key  = (GBT_VARKEY   *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) );
+  void             *qtst  = ( void * ) DatumGetPointer( PG_GETARG_DATUM(1) );
+  void            *query  = ( void * ) DatumGetByteaP ( PG_GETARG_DATUM(1) );
+  StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+  bool    retval          = FALSE;
+  GBT_VARKEY_R          r =  gbt_var_key_readable ( key );
+
+  if ( GIST_LEAF(entry) )
+  {
+    retval = gbt_var_consistent( &r, query, &strategy, TRUE, &tinfo );
+  } else {
+    bytea * q = gbt_bit_xfrm ( ( bytea * ) query );
+    retval    = gbt_var_consistent( &r, (void*)q, &strategy, FALSE, &tinfo );
+    pfree(q);
+  }
+
+  if ( ktst != key ){
+    pfree ( key );
+  }
+  if ( qtst != query ){
+    pfree ( query );
+  }
+  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 , &tinfo ) );
+}
+ 
+
+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, &tinfo );
+    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);
+    PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo ));
+}
+
+
+Datum
+gbt_bit_penalty(PG_FUNCTION_ARGS)
+{
+    float      *result   = (float *)     PG_GETARG_POINTER(2);
+    GISTENTRY *      o   = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY *      n   = (GISTENTRY *) PG_GETARG_POINTER(1);
+    PG_RETURN_POINTER( gbt_var_penalty ( result ,o , n, &tinfo ) );
+}
+

contrib/btree_gist/btree_bytea.c

@@ -0,0 +1,149 @@
+#include "btree_gist.h"
+#include "btree_utils_var.h"
+#include "utils/builtins.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);
+
+Datum    gbt_bytea_compress(PG_FUNCTION_ARGS);
+Datum    gbt_bytea_union(PG_FUNCTION_ARGS);
+Datum    gbt_bytea_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_bytea_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_bytea_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_bytea_same(PG_FUNCTION_ARGS);
+
+
+/* define for comparison */
+
+static bool     gbt_byteagt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( byteagt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_byteage     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( byteage ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_byteaeq     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( byteaeq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_byteale     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( byteale ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_bytealt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( bytealt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+ 
+
+static int32 gbt_byteacmp ( const bytea * a , const bytea * b )
+{
+  return 
+    ( DatumGetInt32(DirectFunctionCall2(byteacmp,PointerGetDatum(a),PointerGetDatum(b) ) ) );
+}
+
+
+static const gbtree_vinfo tinfo =
+{
+  gbt_t_bytea,
+  FALSE,
+  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);
+  GBT_VARKEY       *ktst  = (GBT_VARKEY   *) DatumGetPointer ( entry->key ) ;
+  GBT_VARKEY        *key  = (GBT_VARKEY   *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) );
+  void             *qtst  = ( void * ) DatumGetPointer( PG_GETARG_DATUM(1) );
+  void            *query  = ( void * ) DatumGetByteaP ( PG_GETARG_DATUM(1) );
+  StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+  bool    retval          = FALSE;
+  GBT_VARKEY_R          r =  gbt_var_key_readable ( key );
+
+  retval = gbt_var_consistent( &r, query, &strategy, GIST_LEAF(entry), &tinfo );
+
+  if ( ktst != key ){
+    pfree ( key );
+  }
+  if ( qtst != query ){
+    pfree ( query );
+  }
+  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 , &tinfo ) );
+}
+ 
+
+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, &tinfo );
+    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);
+    PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo ));
+}
+
+
+Datum
+gbt_bytea_penalty(PG_FUNCTION_ARGS)
+{
+    float      *result   = (float *)     PG_GETARG_POINTER(2);
+    GISTENTRY *      o   = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY *      n   = (GISTENTRY *) PG_GETARG_POINTER(1);
+    PG_RETURN_POINTER( gbt_var_penalty ( result ,o , n, &tinfo ) );
+}
+

contrib/btree_gist/btree_cash.c

@@ -0,0 +1,163 @@
+#include "btree_gist.h"
+#include "btree_utils_num.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_union);
+PG_FUNCTION_INFO_V1(gbt_cash_picksplit);
+PG_FUNCTION_INFO_V1(gbt_cash_consistent);
+PG_FUNCTION_INFO_V1(gbt_cash_penalty);
+PG_FUNCTION_INFO_V1(gbt_cash_same);
+
+Datum    gbt_cash_compress(PG_FUNCTION_ARGS);
+Datum    gbt_cash_union(PG_FUNCTION_ARGS);
+Datum    gbt_cash_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_cash_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_cash_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_cash_same(PG_FUNCTION_ARGS);
+
+static bool     gbt_cashgt     (const void *a, const void *b)
+{
+  return ( *((Cash*)a) >  *((Cash*)b) ); 
+}
+static bool     gbt_cashge     (const void *a, const void *b)
+{
+  return ( *((Cash*)a) >= *((Cash*)b) ); 
+}
+static bool     gbt_casheq     (const void *a, const void *b)
+{
+  return ( *((Cash*)a) == *((Cash*)b) ); 
+}
+static bool     gbt_cashle     (const void *a, const void *b)
+{
+  return ( *((Cash*)a) <= *((Cash*)b) ); 
+}
+static bool     gbt_cashlt     (const void *a, const void *b)
+{
+  return ( *((Cash*)a) <  *((Cash*)b) ); 
+}
+
+static int
+gbt_cashkey_cmp(const void *a, const void *b)
+{
+
+  if ( *(Cash*)&(((Nsrt *) a)->t[0]) >  *(Cash*)&(((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(Cash*)&(((Nsrt *) a)->t[0]) <  *(Cash*)&(((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{
+  gbt_t_cash,
+  sizeof(Cash),
+  gbt_cashgt,
+  gbt_cashge,
+  gbt_casheq,
+  gbt_cashle,
+  gbt_cashlt,
+  gbt_cashkey_cmp
+};
+
+
+/**************************************************
+ * Cash ops
+ **************************************************/
+
+
+Datum
+gbt_cash_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_cash_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    Cash              query = (*((Cash *) PG_GETARG_POINTER(1)));
+    cashKEY            *kkk = (cashKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+
+  Cash              res ;
+
+  *result = 0.0;
+ 
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}
+
+

contrib/btree_gist/btree_common.c

@@ -1,69 +0,0 @@
-#include "btree_gist.h"
-
-PG_FUNCTION_INFO_V1(btree_decompress);
-Datum		btree_decompress(PG_FUNCTION_ARGS);
-
-/*
-** GiST DeCompress methods
-** do not do anything.
-*/
-Datum
-btree_decompress(PG_FUNCTION_ARGS)
-{
-	PG_RETURN_POINTER(PG_GETARG_POINTER(0));
-}
-
-
-/**************************************************
- * Common btree-function (for all ops)
- **************************************************/
-
-/*
-** The GiST PickSplit method
-*/
-extern GIST_SPLITVEC *
-btree_picksplit(GistEntryVector *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
-{
-	OffsetNumber i;
-	RIX		   *array;
-	OffsetNumber maxoff;
-	int			nbytes;
-
-	maxoff = entryvec->n - 1;
-	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
-	v->spl_left = (OffsetNumber *) palloc(nbytes);
-	v->spl_right = (OffsetNumber *) palloc(nbytes);
-	v->spl_nleft = 0;
-	v->spl_nright = 0;
-	v->spl_ldatum = PointerGetDatum(0);
-	v->spl_rdatum = PointerGetDatum(0);
-	array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
-
-	/* copy the data into RIXes, and sort the RIXes */
-	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
-	{
-		array[i].index = i;
-		array[i].r = (char *) DatumGetPointer((entryvec->vector[i].key));
-	}
-	qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
-		  sizeof(RIX), cmp);
-
-	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
-	{
-		if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
-		{
-			v->spl_left[v->spl_nleft] = array[i].index;
-			v->spl_nleft++;
-			(*bu) (&v->spl_ldatum, array[i].r);
-		}
-		else
-		{
-			v->spl_right[v->spl_nright] = array[i].index;
-			v->spl_nright++;
-			(*bu) (&v->spl_rdatum, array[i].r);
-		}
-	}
-	pfree(array);
-
-	return (v);
-}

contrib/btree_gist/btree_date.c

@@ -0,0 +1,191 @@
+#include "btree_gist.h"
+#include "btree_utils_num.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_union);
+PG_FUNCTION_INFO_V1(gbt_date_picksplit);
+PG_FUNCTION_INFO_V1(gbt_date_consistent);
+PG_FUNCTION_INFO_V1(gbt_date_penalty);
+PG_FUNCTION_INFO_V1(gbt_date_same);
+
+Datum    gbt_date_compress(PG_FUNCTION_ARGS);
+Datum    gbt_date_union(PG_FUNCTION_ARGS);
+Datum    gbt_date_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_date_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_date_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_date_same(PG_FUNCTION_ARGS);
+
+static bool     gbt_dategt     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(date_gt,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) )
+  );
+}
+
+static bool     gbt_datege     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(date_ge,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) )
+  );
+}
+
+static bool     gbt_dateeq     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(date_eq,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) )
+  );
+}
+
+static bool     gbt_datele     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(date_le,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) )
+  );
+}
+
+static bool     gbt_datelt     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(date_lt,DateADTGetDatum( *((DateADT*)a) ), DateADTGetDatum( *((DateADT*)b) ) )
+  );
+}
+
+
+
+static int
+gbt_datekey_cmp(const void *a, const void *b)
+{
+  if ( gbt_dategt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){
+    return  1;
+  } else
+  if ( gbt_datelt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){
+    return -1;
+  }
+  return  0;
+}
+
+
+static const gbtree_ninfo tinfo = 
+{
+  gbt_t_date,
+  sizeof(DateADT),
+  gbt_dategt,
+  gbt_datege,
+  gbt_dateeq,
+  gbt_datele,
+  gbt_datelt,
+  gbt_datekey_cmp
+};
+
+
+/**************************************************
+ * date ops
+ **************************************************/
+
+
+
+Datum
+gbt_date_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+
+Datum
+gbt_date_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    DateADT          query  = PG_GETARG_DATEADT( 1 );
+    dateKEY            *kkk = (dateKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}

contrib/btree_gist/btree_float4.c

@@ -0,0 +1,161 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+
+typedef struct float4key
+{
+   float4    lower;
+   float4    upper;
+}  float4KEY;
+
+/*
+** float4 ops
+*/
+PG_FUNCTION_INFO_V1(gbt_float4_compress);
+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_penalty);
+PG_FUNCTION_INFO_V1(gbt_float4_same);
+
+Datum    gbt_float4_compress(PG_FUNCTION_ARGS);
+Datum    gbt_float4_union(PG_FUNCTION_ARGS);
+Datum    gbt_float4_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_float4_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_float4_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_float4_same(PG_FUNCTION_ARGS);
+
+static bool     gbt_float4gt     (const void *a, const void *b)
+{
+  return ( *((float4*)a) >  *((float4*)b) ); 
+}
+static bool     gbt_float4ge     (const void *a, const void *b)
+{
+  return ( *((float4*)a) >= *((float4*)b) ); 
+}
+static bool     gbt_float4eq     (const void *a, const void *b)
+{
+  return ( *((float4*)a) == *((float4*)b) ); 
+}
+static bool     gbt_float4le     (const void *a, const void *b)
+{
+  return ( *((float4*)a) <= *((float4*)b) ); 
+}
+static bool     gbt_float4lt     (const void *a, const void *b)
+{
+  return ( *((float4*)a) <  *((float4*)b) ); 
+}
+
+static int
+gbt_float4key_cmp(const void *a, const void *b)
+{
+
+  if ( *(float4*)&(((Nsrt *) a)->t[0]) >  *(float4*)&(((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(float4*)&(((Nsrt *) a)->t[0]) <  *(float4*)&(((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{ 
+  gbt_t_float4,
+  sizeof(float4),
+  gbt_float4gt,
+  gbt_float4ge,
+  gbt_float4eq,
+  gbt_float4le,
+  gbt_float4lt,
+  gbt_float4key_cmp
+};
+
+
+/**************************************************
+ * float4 ops
+ **************************************************/
+
+
+Datum
+gbt_float4_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_float4_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    float4             query = PG_GETARG_FLOAT4(1);
+    float4KEY           *kkk = (float4KEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+
+  float4              res ;
+
+  *result = 0.0;
+ 
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}
+

contrib/btree_gist/btree_float8.c

@@ -0,0 +1,161 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+
+typedef struct float8key
+{
+   float8    lower;
+   float8    upper;
+}  float8KEY;
+
+/*
+** float8 ops
+*/
+PG_FUNCTION_INFO_V1(gbt_float8_compress);
+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_penalty);
+PG_FUNCTION_INFO_V1(gbt_float8_same);
+
+Datum    gbt_float8_compress(PG_FUNCTION_ARGS);
+Datum    gbt_float8_union(PG_FUNCTION_ARGS);
+Datum    gbt_float8_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_float8_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_float8_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_float8_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_float8gt     (const void *a, const void *b)
+{
+  return ( *((float8*)a) >  *((float8*)b) ); 
+}
+static bool     gbt_float8ge     (const void *a, const void *b)
+{
+  return ( *((float8*)a) >= *((float8*)b) ); 
+}
+static bool     gbt_float8eq     (const void *a, const void *b)
+{
+  return ( *((float8*)a) == *((float8*)b) ); 
+}
+static bool     gbt_float8le     (const void *a, const void *b)
+{
+  return ( *((float8*)a) <= *((float8*)b) ); 
+}
+static bool     gbt_float8lt     (const void *a, const void *b)
+{
+  return ( *((float8*)a) <  *((float8*)b) ); 
+}
+
+static int
+gbt_float8key_cmp(const void *a, const void *b)
+{
+
+  if ( *(float8*)&(((Nsrt *) a)->t[0]) >  *(float8*)&(((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(float8*)&(((Nsrt *) a)->t[0]) <  *(float8*)&(((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{ 
+  gbt_t_float8,
+  sizeof(float8),
+  gbt_float8gt,
+  gbt_float8ge,
+  gbt_float8eq,
+  gbt_float8le,
+  gbt_float8lt,
+  gbt_float8key_cmp
+};
+
+
+/**************************************************
+ * float8 ops
+ **************************************************/
+
+
+Datum
+gbt_float8_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_float8_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    float8            query = PG_GETARG_FLOAT8(1);
+    float8KEY          *kkk = (float8KEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+
+  float8               res ;
+
+  *result = 0.0;
+ 
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}

contrib/btree_gist/btree_gist.c

@@ -0,0 +1,45 @@
+#include "btree_gist.h"
+
+PG_FUNCTION_INFO_V1(gbt_decompress);
+PG_FUNCTION_INFO_V1(gbtreekey_in);             
+PG_FUNCTION_INFO_V1(gbtreekey_out);
+
+Datum    gbt_decompress(PG_FUNCTION_ARGS);
+
+/**************************************************
+ * 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));
+}
+

contrib/btree_gist/btree_gist.h

@@ -1,25 +1,39 @@
 #include "postgres.h"
-
 #include "access/gist.h"
 #include "access/itup.h"
 #include "access/nbtree.h"
-#include "utils/geo_decls.h"
 
-typedef int (*CMPFUNC) (const void *a, const void *b);
+/* indexed types */
-typedef void (*BINARY_UNION) (Datum *, char *);
 
-
+enum gbtree_type
-/* used for sorting */
-
-typedef struct rix
 {
-	int			index;
+ gbt_t_var  ,
-	char	   *r;
+ gbt_t_int2 ,
-}	RIX;
+ 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_text,
+ gbt_t_bpchar,
+ gbt_t_bytea,
+ gbt_t_bit,
+ gbt_t_inet
+};
+
+
 
 /*
-** Common btree-function (for all ops)
+ * Generic btree functions
-*/
+ */
 
-extern GIST_SPLITVEC *btree_picksplit(GistEntryVector *entryvec, GIST_SPLITVEC *v,
+Datum                 gbtreekey_in (PG_FUNCTION_ARGS);
-				BINARY_UNION bu, CMPFUNC cmp);
+
+Datum                 gbtreekey_out(PG_FUNCTION_ARGS);

contrib/btree_gist/btree_inet.c

@@ -0,0 +1,224 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+#include "utils/builtins.h"
+#include "utils/inet.h"
+#include "catalog/pg_type.h"
+
+typedef struct inetkey
+{
+   double    lower;
+   double    upper;
+}  inetKEY;
+
+/*
+** inet ops
+*/
+PG_FUNCTION_INFO_V1(gbt_inet_compress);
+PG_FUNCTION_INFO_V1(gbt_cidr_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_cidr_consistent);
+PG_FUNCTION_INFO_V1(gbt_inet_penalty);
+PG_FUNCTION_INFO_V1(gbt_inet_same);
+
+Datum    gbt_inet_compress(PG_FUNCTION_ARGS);
+Datum    gbt_cidr_compress(PG_FUNCTION_ARGS);
+Datum    gbt_inet_union(PG_FUNCTION_ARGS);
+Datum    gbt_inet_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_inet_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_cidr_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_inet_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_inet_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_inetgt     (const void *a, const void *b)
+{
+  return ( *((double*)a) >  *((double*)b) ); 
+}
+static bool     gbt_inetge     (const void *a, const void *b)
+{
+  return ( *((double*)a) >= *((double*)b) ); 
+}
+static bool     gbt_ineteq     (const void *a, const void *b)
+{
+  return ( *((double*)a) == *((double*)b) ); 
+}
+static bool     gbt_inetle     (const void *a, const void *b)
+{
+  return ( *((double*)a) <= *((double*)b) ); 
+}
+static bool     gbt_inetlt     (const void *a, const void *b)
+{
+  return ( *((double*)a) <  *((double*)b) ); 
+}
+
+static int
+gbt_inetkey_cmp(const void *a, const void *b)
+{
+
+  if ( *(double*)(&((Nsrt *) a)->t[0]) >  *(double*)(&((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(double*)(&((Nsrt *) a)->t[0]) <  *(double*)(&((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{
+  gbt_t_inet,
+  sizeof(double),
+  gbt_inetgt,
+  gbt_inetge,
+  gbt_ineteq,
+  gbt_inetle,
+  gbt_inetlt,
+  gbt_inetkey_cmp
+};
+
+
+/**************************************************
+ * inet ops
+ **************************************************/
+
+
+
+static GISTENTRY  *
+gbt_inet_compress_inetrnal(GISTENTRY  *retval , GISTENTRY  *entry , Oid typid)
+{
+  
+  if (entry->leafkey)
+  {
+    inetKEY  *r = (inetKEY *) palloc(sizeof(inetKEY));
+    retval   = palloc(sizeof(GISTENTRY));
+    r->lower = convert_network_to_scalar(entry->key, typid );
+    r->upper = r->lower ;
+    gistentryinit(*retval, PointerGetDatum(r),
+         entry->rel, entry->page,
+         entry->offset, sizeof(inetKEY), FALSE);
+  }
+  else
+        retval = entry;
+
+  return ( retval );
+}
+
+
+
+Datum
+gbt_inet_compress(PG_FUNCTION_ARGS)
+{
+  GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+  GISTENTRY  *retval = NULL;
+  PG_RETURN_POINTER( gbt_inet_compress_inetrnal(retval ,entry ,INETOID ) );
+}
+
+Datum
+gbt_cidr_compress(PG_FUNCTION_ARGS)
+{
+  GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+  GISTENTRY  *retval = NULL;
+  PG_RETURN_POINTER( gbt_inet_compress_inetrnal(retval ,entry ,CIDROID ) );
+}
+
+
+static bool
+gbt_inet_consistent_internal (
+  const GISTENTRY * entry,
+  const double    * query,
+  const StrategyNumber * strategy
+){
+    inetKEY            *kkk = (inetKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    key.lower = (GBT_NUMKEY*) &kkk->lower ;
+    key.upper = (GBT_NUMKEY*) &kkk->upper ;
+
+    return (
+      gbt_num_consistent( &key, (void*)query,strategy,GIST_LEAF(entry),&tinfo)
+    );
+}
+
+
+Datum
+gbt_inet_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    double            query = convert_network_to_scalar( PG_GETARG_DATUM(1) ,INETOID );
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
+    PG_RETURN_BOOL(
+       gbt_inet_consistent_internal ( entry, &query, &strategy )
+    );
+}
+
+Datum
+gbt_cidr_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    double            query = convert_network_to_scalar( PG_GETARG_DATUM(1) ,CIDROID );
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
+    PG_RETURN_BOOL(
+       gbt_inet_consistent_internal ( entry, &query, &strategy )
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+
+  double            res ;
+
+  *result = 0.0;
+
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}

contrib/btree_gist/btree_int2.c

@@ -0,0 +1,162 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+
+typedef struct int16key
+{
+   int16    lower;
+   int16    upper;
+}  int16KEY;
+
+/*
+** int16 ops
+*/
+PG_FUNCTION_INFO_V1(gbt_int2_compress);
+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_penalty);
+PG_FUNCTION_INFO_V1(gbt_int2_same);
+
+Datum    gbt_int2_compress(PG_FUNCTION_ARGS);
+Datum    gbt_int2_union(PG_FUNCTION_ARGS);
+Datum    gbt_int2_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_int2_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_int2_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_int2_same(PG_FUNCTION_ARGS);
+
+static bool     gbt_int2gt     (const void *a, const void *b)
+{
+  return ( *((int16*)a) >  *((int16*)b) ); 
+}
+static bool     gbt_int2ge     (const void *a, const void *b)
+{
+  return ( *((int16*)a) >= *((int16*)b) ); 
+}
+static bool     gbt_int2eq     (const void *a, const void *b)
+{
+  return ( *((int16*)a) == *((int16*)b) ); 
+}
+static bool     gbt_int2le     (const void *a, const void *b)
+{
+  return ( *((int16*)a) <= *((int16*)b) ); 
+}
+static bool     gbt_int2lt     (const void *a, const void *b)
+{
+  return ( *((int16*)a) <  *((int16*)b) ); 
+}
+
+static int
+gbt_int2key_cmp(const void *a, const void *b)
+{
+
+  if ( *(int16*)(&((Nsrt *) a)->t[0]) >  *(int16*)&(((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(int16*)&(((Nsrt *) a)->t[0]) <  *(int16*)&(((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{ 
+  gbt_t_int2,
+  sizeof(int16),
+  gbt_int2gt,
+  gbt_int2ge,
+  gbt_int2eq,
+  gbt_int2le,
+  gbt_int2lt,
+  gbt_int2key_cmp
+};
+
+
+
+
+
+
+/**************************************************
+ * int16 ops
+ **************************************************/
+
+
+Datum
+gbt_int2_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_int2_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    int16             query = PG_GETARG_INT16(1);
+    int16KEY           *kkk = (int16KEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+  int2              res  ;
+
+  *result = 0.0;
+
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}

contrib/btree_gist/btree_int4.c

@@ -0,0 +1,159 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+
+typedef struct int32key
+{
+   int32    lower;
+   int32    upper;
+}  int32KEY;
+
+/*
+** int32 ops
+*/
+PG_FUNCTION_INFO_V1(gbt_int4_compress);
+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_penalty);
+PG_FUNCTION_INFO_V1(gbt_int4_same);
+
+Datum    gbt_int4_compress(PG_FUNCTION_ARGS);
+Datum    gbt_int4_union(PG_FUNCTION_ARGS);
+Datum    gbt_int4_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_int4_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_int4_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_int4_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_int4gt     (const void *a, const void *b)
+{
+  return ( *((int32*)a) >  *((int32*)b) ); 
+}
+static bool     gbt_int4ge     (const void *a, const void *b)
+{
+  return ( *((int32*)a) >= *((int32*)b) ); 
+}
+static bool     gbt_int4eq     (const void *a, const void *b)
+{
+  return ( *((int32*)a) == *((int32*)b) ); 
+}
+static bool     gbt_int4le     (const void *a, const void *b)
+{
+  return ( *((int32*)a) <= *((int32*)b) ); 
+}
+static bool     gbt_int4lt     (const void *a, const void *b)
+{
+  return ( *((int32*)a) <  *((int32*)b) ); 
+}
+
+static int
+gbt_int4key_cmp(const void *a, const void *b)
+{
+
+  if ( *(int32*)&(((Nsrt *) a)->t[0]) >  *(int32*)&(((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(int32*)&(((Nsrt *) a)->t[0]) <  *(int32*)&(((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{ 
+  gbt_t_int4,
+  sizeof(int32),
+  gbt_int4gt,
+  gbt_int4ge,
+  gbt_int4eq,
+  gbt_int4le,
+  gbt_int4lt,
+  gbt_int4key_cmp
+};
+
+
+/**************************************************
+ * int32 ops
+ **************************************************/
+
+
+Datum
+gbt_int4_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_int4_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    int32             query = PG_GETARG_INT32(1);
+    int32KEY           *kkk = (int32KEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+  int4              res  ;
+
+  *result = 0.0;
+
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}

contrib/btree_gist/btree_int8.c

@@ -0,0 +1,161 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+
+typedef struct int64key
+{
+   int64    lower;
+   int64    upper;
+}  int64KEY;
+
+/*
+** int64 ops
+*/
+PG_FUNCTION_INFO_V1(gbt_int8_compress);
+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_penalty);
+PG_FUNCTION_INFO_V1(gbt_int8_same);
+
+Datum    gbt_int8_compress(PG_FUNCTION_ARGS);
+Datum    gbt_int8_union(PG_FUNCTION_ARGS);
+Datum    gbt_int8_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_int8_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_int8_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_int8_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_int8gt     (const void *a, const void *b)
+{
+  return ( *((int64*)a) >  *((int64*)b) ); 
+}
+static bool     gbt_int8ge     (const void *a, const void *b)
+{
+  return ( *((int64*)a) >= *((int64*)b) ); 
+}
+static bool     gbt_int8eq     (const void *a, const void *b)
+{
+  return ( *((int64*)a) == *((int64*)b) ); 
+}
+static bool     gbt_int8le     (const void *a, const void *b)
+{
+  return ( *((int64*)a) <= *((int64*)b) ); 
+}
+static bool     gbt_int8lt     (const void *a, const void *b)
+{
+  return ( *((int64*)a) <  *((int64*)b) ); 
+}
+
+static int
+gbt_int8key_cmp(const void *a, const void *b)
+{
+
+  if ( *(int64*)&(((Nsrt *) a)->t[0]) >  *(int64*)&(((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(int64*)&(((Nsrt *) a)->t[0]) <  *(int64*)&(((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{
+  gbt_t_int8,
+  sizeof(int64),
+  gbt_int8gt,
+  gbt_int8ge,
+  gbt_int8eq,
+  gbt_int8le,
+  gbt_int8lt,
+  gbt_int8key_cmp
+};
+
+
+/**************************************************
+ * int64 ops
+ **************************************************/
+
+
+Datum
+gbt_int8_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_int8_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    int64             query = PG_GETARG_INT64(1);
+    int64KEY           *kkk = (int64KEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+  int64              res ;
+
+  *result = 0.0;
+
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}
+

contrib/btree_gist/btree_interval.c

@@ -0,0 +1,196 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+
+typedef struct
+{
+   Interval    lower,
+               upper;
+}   intvKEY;
+
+
+/*
+** Interval ops
+*/
+PG_FUNCTION_INFO_V1(gbt_intv_compress);
+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_penalty);
+PG_FUNCTION_INFO_V1(gbt_intv_same);
+
+Datum    gbt_intv_compress(PG_FUNCTION_ARGS);
+Datum    gbt_intv_union(PG_FUNCTION_ARGS);
+Datum    gbt_intv_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_intv_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_intv_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_intv_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_intvgt     (const void *a, const void *b)
+{
+   return DirectFunctionCall2 ( interval_gt , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) );
+}
+
+static bool     gbt_intvge     (const void *a, const void *b)
+{
+   return DirectFunctionCall2 ( interval_ge , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) );
+}
+
+static bool     gbt_intveq     (const void *a, const void *b)
+{
+   return DirectFunctionCall2 ( interval_eq , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) );
+}
+
+static bool     gbt_intvle     (const void *a, const void *b)
+{
+   return DirectFunctionCall2 ( interval_le , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) );
+}
+
+static bool     gbt_intvlt     (const void *a, const void *b)
+{
+   return DirectFunctionCall2 ( interval_lt , IntervalPGetDatum ( a ) , IntervalPGetDatum ( b ) );
+}
+
+static int
+gbt_intvkey_cmp(const void *a, const void *b)
+{
+  return DatumGetInt32 ( 
+     DirectFunctionCall2 ( interval_cmp ,
+       IntervalPGetDatum(&((Nsrt *) a)->t[0]) ,
+       IntervalPGetDatum(&((Nsrt *) b)->t[0])
+     ) 
+   );
+}
+
+static const gbtree_ninfo tinfo = 
+{
+  gbt_t_intv,
+  sizeof(Interval),
+  gbt_intvgt,
+  gbt_intvge,
+  gbt_intveq,
+  gbt_intvle,
+  gbt_intvlt,
+  gbt_intvkey_cmp
+};
+
+
+/**************************************************
+ * interval ops
+ **************************************************/
+
+
+Datum
+gbt_intv_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+ 
+
+Datum
+gbt_intv_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    Interval         *query = PG_GETARG_INTERVAL_P(1);
+    intvKEY            *kkk = (intvKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+  Interval   *intr;
+#ifdef HAVE_INT64_TIMESTAMP
+  int64      res;
+#else
+  double     res;
+#endif
+
+  intr = DatumGetIntervalP(DirectFunctionCall2(
+            interval_mi,
+            IntervalPGetDatum(&newentry->upper),
+            IntervalPGetDatum(&origentry->upper)
+  ));
+
+  /* see interval_larger */
+
+  res  = Max(intr->time + intr->month * (30 * 86400), 0);
+  pfree(intr);
+
+  intr = DatumGetIntervalP(DirectFunctionCall2(   
+            interval_mi,
+            IntervalPGetDatum(&origentry->lower),
+            IntervalPGetDatum(&newentry->lower)
+  ));
+
+  /* see interval_larger */
+  res += Max(intr->time + intr->month * (30 * 86400), 0);
+  pfree(intr);
+
+  *result = 0.0;
+
+  if ( res > 0 ){
+
+    intr = DatumGetIntervalP(DirectFunctionCall2(   
+              interval_mi,
+              IntervalPGetDatum(&origentry->upper),
+              IntervalPGetDatum(&origentry->lower)
+    ));
+
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + intr->time + intr->month * (30 * 86400) ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+    
+    pfree ( intr );
+
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}
+

contrib/btree_gist/btree_macaddr.c

@@ -0,0 +1,183 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+#include "utils/builtins.h"
+#include "utils/inet.h"
+
+typedef struct
+{
+   macaddr    lower;
+   macaddr    upper;
+}  macKEY;
+
+/*
+** OID ops
+*/
+PG_FUNCTION_INFO_V1(gbt_macad_compress);
+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);
+
+Datum    gbt_macad_compress(PG_FUNCTION_ARGS);
+Datum    gbt_macad_union(PG_FUNCTION_ARGS);
+Datum    gbt_macad_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_macad_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_macad_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_macad_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_macadgt     (const void *a, const void *b)
+{
+  return DatumGetBool(DirectFunctionCall2(macaddr_gt,PointerGetDatum(a),PointerGetDatum(b)));
+}
+static bool     gbt_macadge     (const void *a, const void *b)
+{
+  return DatumGetBool(DirectFunctionCall2(macaddr_ge,PointerGetDatum(a),PointerGetDatum(b)));
+}
+
+static bool     gbt_macadeq     (const void *a, const void *b)
+{
+  return DatumGetBool(DirectFunctionCall2(macaddr_eq,PointerGetDatum(a),PointerGetDatum(b)));
+}
+
+static bool     gbt_macadle     (const void *a, const void *b)
+{
+  return DatumGetBool(DirectFunctionCall2(macaddr_le,PointerGetDatum(a),PointerGetDatum(b)));
+}
+
+static bool     gbt_macadlt     (const void *a, const void *b)
+{
+  return DatumGetBool(DirectFunctionCall2(macaddr_lt,PointerGetDatum(a),PointerGetDatum(b)));
+}
+
+
+static int
+gbt_macadkey_cmp(const void *a, const void *b)
+{
+        return DatumGetInt32(
+            DirectFunctionCall2(
+              macaddr_cmp ,
+              PointerGetDatum (&((Nsrt *) a)->t[0]),
+              PointerGetDatum (&((Nsrt *) b)->t[0])
+            )
+        );
+}
+
+
+static const gbtree_ninfo tinfo = 
+{ 
+  gbt_t_macad,
+  sizeof(macaddr),
+  gbt_macadgt,
+  gbt_macadge,
+  gbt_macadeq,
+  gbt_macadle,
+  gbt_macadlt,
+  gbt_macadkey_cmp
+};
+
+
+/**************************************************
+ * macaddr ops
+ **************************************************/
+
+
+
+static int64 mac_2_int64  ( macaddr * m ){
+   unsigned char * mi = ( unsigned char * ) m;
+   int64    res = 0;
+   int i;
+   for (i=0; i<6; i++ ){
+     res += mi[i] << ( (5-i)*8 );
+   }
+   return res;
+}
+
+
+
+Datum
+gbt_macad_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_macad_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    macaddr          *query = (macaddr *) PG_GETARG_POINTER(1);
+    macKEY             *kkk = (macKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+Datum
+gbt_macad_union(PG_FUNCTION_ARGS)
+{
+    GistEntryVector     *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
+    void                     *out = palloc(sizeof(macKEY));
+    *(int *) PG_GETARG_POINTER(1) = sizeof(macKEY);
+    PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) );
+}
+
+
+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);
+        int64      iorg[2], inew[2], res ;
+
+        iorg[0] =  mac_2_int64 ( &origentry->lower );
+        iorg[1] =  mac_2_int64 ( &origentry->upper );
+        inew[0] =  mac_2_int64 ( &newentry->lower  );
+        inew[1] =  mac_2_int64 ( &newentry->upper  );
+
+        res = Max(inew[1] - iorg[1], 0) +
+                Max(iorg[0] - inew[0] , 0);
+
+        *result = 0.0;
+
+        if ( res > 0 ){
+          *result += FLT_MIN ;
+          *result += (float) ( res / ( (double) ( res + iorg[1] - iorg[0] ) ) );
+          *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}
+

contrib/btree_gist/btree_num.c.in

@@ -1,266 +0,0 @@
-#include "btree_gist.h"
-
-#define __DEFINE_BTREE_TYPE_HERE__ 1
-
-typedef struct __BTREE_GIST_TYPE__key
-{
-	__BTREE_GIST_TYPE__		lower;
-	__BTREE_GIST_TYPE__		upper;
-}	__BTREE_GIST_TYPE__KEY;
-
-
-/*
-** __BTREE_GIST_TYPE__key in/out
-*/
-PG_FUNCTION_INFO_V1(__BTREE_GIST_TYPE2__key_in);
-PG_FUNCTION_INFO_V1(__BTREE_GIST_TYPE2__key_out);
-Datum		__BTREE_GIST_TYPE2__key_in(PG_FUNCTION_ARGS);
-Datum		__BTREE_GIST_TYPE2__key_out(PG_FUNCTION_ARGS);
-
-/*
-** __BTREE_GIST_TYPE__ ops
-*/
-PG_FUNCTION_INFO_V1(g__BTREE_GIST_TYPE2___compress);
-PG_FUNCTION_INFO_V1(g__BTREE_GIST_TYPE2___union);
-PG_FUNCTION_INFO_V1(g__BTREE_GIST_TYPE2___picksplit);
-PG_FUNCTION_INFO_V1(g__BTREE_GIST_TYPE2___consistent);
-PG_FUNCTION_INFO_V1(g__BTREE_GIST_TYPE2___penalty);
-PG_FUNCTION_INFO_V1(g__BTREE_GIST_TYPE2___same);
-
-Datum		g__BTREE_GIST_TYPE2___compress(PG_FUNCTION_ARGS);
-Datum		g__BTREE_GIST_TYPE2___union(PG_FUNCTION_ARGS);
-Datum		g__BTREE_GIST_TYPE2___picksplit(PG_FUNCTION_ARGS);
-Datum		g__BTREE_GIST_TYPE2___consistent(PG_FUNCTION_ARGS);
-Datum		g__BTREE_GIST_TYPE2___penalty(PG_FUNCTION_ARGS);
-Datum		g__BTREE_GIST_TYPE2___same(PG_FUNCTION_ARGS);
-
-static void g__BTREE_GIST_TYPE2___binary_union(Datum *r1, char *r2);
-static int	__BTREE_GIST_TYPE2__key_cmp(const void *a, const void *b);
-
-
-/**************************************************
- * __BTREE_GIST_TYPE__ ops
- **************************************************/
-
-Datum
-g__BTREE_GIST_TYPE2___compress(PG_FUNCTION_ARGS)
-{
-	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
-	GISTENTRY  *retval;
-
-	if (entry->leafkey)
-	{
-		__BTREE_GIST_TYPE__KEY    *r = ( __BTREE_GIST_TYPE__KEY * ) palloc(sizeof(__BTREE_GIST_TYPE__KEY));
-    #ifdef BTREE_GIST_INT2
-    	int16		leaf = DatumGetInt16(entry->key);
-    #endif
-    #ifdef BTREE_GIST_INT4
-    	int32		leaf = DatumGetInt32(entry->key);
-    #endif
-    #ifdef BTREE_GIST_INT8
-    	int64		leaf = DatumGetInt64(entry->key);
-    #endif
-    #ifdef BTREE_GIST_FLOAT4
-    	float4	leaf = DatumGetFloat4(entry->key);
-    #endif
-    #ifdef BTREE_GIST_FLOAT8
-    	float8	leaf = DatumGetFloat8(entry->key);
-    #endif
-
-		retval = palloc(sizeof(GISTENTRY));
-		r->lower = r->upper = leaf ;
-
-		gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
-					  entry->offset, sizeof(__BTREE_GIST_TYPE__KEY), FALSE);
-
-	}
-	else
-		retval = entry;
-	PG_RETURN_POINTER(retval);
-}
-
-Datum
-g__BTREE_GIST_TYPE2___consistent(PG_FUNCTION_ARGS)
-{
-	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
-  #ifdef BTREE_GIST_INT2
-  	int16		query = PG_GETARG_INT16(1);
-  #endif
-  #ifdef BTREE_GIST_INT4
-  	int32		query = PG_GETARG_INT32(1);
-  #endif
-  #ifdef BTREE_GIST_INT8
-  	int64		query = PG_GETARG_INT64(1);
-  #endif
-  #ifdef BTREE_GIST_FLOAT4
-  	float4		query = PG_GETARG_FLOAT4(1);
-  #endif
-  #ifdef BTREE_GIST_FLOAT8
-  	float8		query = PG_GETARG_FLOAT8(1);
-  #endif
-	__BTREE_GIST_TYPE__KEY    *kkk = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer(entry->key);
-	StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
-	bool		retval;
-
-	switch (strategy)
-	{
-		case BTLessEqualStrategyNumber:
-			retval = (query >= kkk->lower);
-			break;
-		case BTLessStrategyNumber:
-			if (GIST_LEAF(entry))
-				retval = (query > kkk->lower);
-			else
-				retval = (query >= kkk->lower);
-			break;
-		case BTEqualStrategyNumber:
-			/* in leaf page kkk->lower always = kkk->upper */
-			if (GIST_LEAF(entry))
-				retval = (query == kkk->lower);
-			else
-				retval = (kkk->lower <= query && query <= kkk->upper);
-			break;
-		case BTGreaterStrategyNumber:
-			if (GIST_LEAF(entry))
-				retval = (query < kkk->upper);
-			else
-				retval = (query <= kkk->upper);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			retval = (query <= kkk->upper);
-			break;
-		default:
-			retval = FALSE;
-	}
-	PG_RETURN_BOOL(retval);
-}
-
-Datum
-g__BTREE_GIST_TYPE2___union(PG_FUNCTION_ARGS)
-{
-	GistEntryVector	   *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
-	int			i,
-				numranges;
-	__BTREE_GIST_TYPE__KEY    *cur,
-			   *out = palloc(sizeof(__BTREE_GIST_TYPE__KEY));
-
-	numranges = entryvec->n;
-	*(int *) PG_GETARG_POINTER(1) = sizeof(__BTREE_GIST_TYPE__KEY);
-
-	cur = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer((entryvec->vector[0].key));
-	out->lower = cur->lower;
-	out->upper = cur->upper;
-
-	for (i = 1; i < numranges; i++)
-	{
-		cur = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer((entryvec->vector[i].key));
-		if (out->lower > cur->lower)
-			out->lower = cur->lower;
-		if (out->upper < cur->upper)
-			out->upper = cur->upper;
-	}
-
-	PG_RETURN_POINTER(out);
-}
-
-Datum
-g__BTREE_GIST_TYPE2___penalty(PG_FUNCTION_ARGS)
-{
-	__BTREE_GIST_TYPE__KEY    *origentry = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
-	__BTREE_GIST_TYPE__KEY    *newentry = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
-	float	   *result = (float *) PG_GETARG_POINTER(2);
-
-	*result = Max(newentry->upper - origentry->upper, 0) +
-		Max(origentry->lower - newentry->lower, 0);
-
-	PG_RETURN_POINTER(result);
-}
-
-Datum
-g__BTREE_GIST_TYPE2___picksplit(PG_FUNCTION_ARGS)
-{
-	PG_RETURN_POINTER(btree_picksplit(
-									  (GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
-									  g__BTREE_GIST_TYPE2___binary_union,
-									  __BTREE_GIST_TYPE2__key_cmp
-									  ));
-}
-
-Datum
-g__BTREE_GIST_TYPE2___same(PG_FUNCTION_ARGS)
-{
-	__BTREE_GIST_TYPE__KEY    *b1 = (__BTREE_GIST_TYPE__KEY *) PG_GETARG_POINTER(0);
-	__BTREE_GIST_TYPE__KEY    *b2 = (__BTREE_GIST_TYPE__KEY *) PG_GETARG_POINTER(1);
-	bool	   *result = (bool *) PG_GETARG_POINTER(2);
-
-	*result = (b1->lower == b2->lower && b1->upper == b2->upper) ? TRUE : FALSE;
-	PG_RETURN_POINTER(result);
-}
-
-static void
-g__BTREE_GIST_TYPE2___binary_union(Datum *r1, char *r2)
-{
-	__BTREE_GIST_TYPE__KEY    *b1;
-	__BTREE_GIST_TYPE__KEY    *b2 = (__BTREE_GIST_TYPE__KEY *) r2;
-
-	if (!DatumGetPointer(*r1))
-	{
-		*r1 = PointerGetDatum(palloc(sizeof(__BTREE_GIST_TYPE__KEY)));
-		b1 = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer(*r1);
-		b1->upper = b2->upper;
-		b1->lower = b2->lower;
-	}
-	else
-	{
-		b1 = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer(*r1);
-
-		b1->lower = (b1->lower > b2->lower) ?
-			b2->lower : b1->lower;
-		b1->upper = (b1->upper > b2->upper) ?
-			b1->upper : b2->upper;
-	}
-
-}
-
-
-static int
-__BTREE_GIST_TYPE2__key_cmp(const void *a, const void *b)
-{
-
-
-	if (((__BTREE_GIST_TYPE__KEY *) (((RIX *) a)->r))->lower > ((__BTREE_GIST_TYPE__KEY *) (((RIX *) b)->r))->lower){
-    return 1;
-	} else if (((__BTREE_GIST_TYPE__KEY *) (((RIX *) a)->r))->lower < ((__BTREE_GIST_TYPE__KEY *) (((RIX *) b)->r))->lower){
-    return -1;
-  } else {
-    return 0;
-  }
-
-}
-
-
-/**************************************************
- * In/Out for keys
- **************************************************/
-
-Datum
-__BTREE_GIST_TYPE2__key_in(PG_FUNCTION_ARGS)
-{
-  ereport(ERROR,
-		(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-		 errmsg("<datatype>key_in() not implemented")));
-
-  PG_RETURN_POINTER(NULL);
-}
-
-Datum
-__BTREE_GIST_TYPE2__key_out(PG_FUNCTION_ARGS)
-{
-  ereport(ERROR,
-		(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-		 errmsg("<datatype>key_out() not implemented")));
-
-  PG_RETURN_POINTER(NULL);
-}
-

contrib/btree_gist/btree_numeric.c

@@ -0,0 +1,227 @@
+#include "btree_gist.h"
+#include "btree_utils_var.h"
+#include "utils/builtins.h"
+#include "utils/numeric.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);
+
+Datum    gbt_numeric_compress(PG_FUNCTION_ARGS);
+Datum    gbt_numeric_union(PG_FUNCTION_ARGS);
+Datum    gbt_numeric_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_numeric_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_numeric_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_numeric_same(PG_FUNCTION_ARGS);
+
+
+/* define for comparison */
+
+static bool     gbt_numeric_gt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( numeric_gt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_numeric_ge     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( numeric_ge ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_numeric_eq     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( numeric_eq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_numeric_le     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( numeric_le ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_numeric_lt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( numeric_lt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+ 
+
+static int32 gbt_numeric_cmp ( const bytea * a , const bytea * b )
+{
+  return 
+    ( DatumGetInt32(DirectFunctionCall2(numeric_cmp,PointerGetDatum(a),PointerGetDatum(b) ) ) );
+}
+
+
+static const gbtree_vinfo tinfo =
+{
+  gbt_t_numeric,
+  FALSE,
+  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);
+  GBT_VARKEY       *ktst  = (GBT_VARKEY   *) DatumGetPointer ( entry->key ) ;
+  GBT_VARKEY        *key  = (GBT_VARKEY   *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) );
+  void             *qtst  = ( void * ) DatumGetPointer ( PG_GETARG_DATUM(1) );
+  void            *query  = ( void * ) DatumGetNumeric ( PG_GETARG_DATUM(1) );
+  StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+  bool    retval          = FALSE;
+  GBT_VARKEY_R          r = gbt_var_key_readable ( key );
+
+  retval = gbt_var_consistent( &r, query, &strategy, GIST_LEAF(entry), &tinfo );
+
+  if ( ktst != key ){
+    pfree ( key );
+  }
+  if ( qtst != query ){
+    pfree ( query );
+  }
+  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 , &tinfo ) );
+}
+ 
+
+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);
+    PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo ));
+}
+
+
+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, TRUE ) );
+    gbt_var_bin_union ( &uni , newe, &tinfo );
+    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)
+    ));
+
+    pfree ( DatumGetPointer(uni) );
+
+    os = DatumGetNumeric(DirectFunctionCall2(
+              numeric_sub,
+              PointerGetDatum(ok.upper),
+              PointerGetDatum(ok.lower)
+    ));
+
+    ds = DatumGetNumeric(DirectFunctionCall2(
+              numeric_sub,
+              NumericGetDatum(us),
+              NumericGetDatum(os)
+    ));
+
+    pfree ( os );
+
+    if ( NUMERIC_IS_NAN( us ) )
+    {
+
+      if ( NUMERIC_IS_NAN( os ) )
+      {
+        *result = 0.0;
+      } else {
+        *result = 1.0;
+      }
+
+    } else {
+
+      Numeric nul = DatumGetNumeric(DirectFunctionCall1( int4_numeric , Int32GetDatum (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) ) );
+        pfree ( os );
+
+      }
+
+      pfree ( nul );
+    }
+
+    if ( *result > 0 )
+      *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+
+    pfree ( us  );
+    pfree ( ds  );
+
+    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, &tinfo );
+    PG_RETURN_POINTER(v);
+}
+

contrib/btree_gist/btree_oid.c

@@ -0,0 +1,160 @@
+#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_union);
+PG_FUNCTION_INFO_V1(gbt_oid_picksplit);
+PG_FUNCTION_INFO_V1(gbt_oid_consistent);
+PG_FUNCTION_INFO_V1(gbt_oid_penalty);
+PG_FUNCTION_INFO_V1(gbt_oid_same);
+
+Datum    gbt_oid_compress(PG_FUNCTION_ARGS);
+Datum    gbt_oid_union(PG_FUNCTION_ARGS);
+Datum    gbt_oid_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_oid_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_oid_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_oid_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_oidgt     (const void *a, const void *b)
+{
+  return ( *((Oid*)a) >  *((Oid*)b) ); 
+}
+static bool     gbt_oidge     (const void *a, const void *b)
+{
+  return ( *((Oid*)a) >= *((Oid*)b) ); 
+}
+static bool     gbt_oideq     (const void *a, const void *b)
+{
+  return ( *((Oid*)a) == *((Oid*)b) ); 
+}
+static bool     gbt_oidle     (const void *a, const void *b)
+{
+  return ( *((Oid*)a) <= *((Oid*)b) ); 
+}
+static bool     gbt_oidlt     (const void *a, const void *b)
+{
+  return ( *((Oid*)a) <  *((Oid*)b) ); 
+}
+
+static int
+gbt_oidkey_cmp(const void *a, const void *b)
+{
+
+  if ( *(Oid*)&(((Nsrt *) a)->t[0]) >  *(Oid*)&(((Nsrt *) b)->t[0]) ){
+    return 1;
+  } else
+  if ( *(Oid*)&(((Nsrt *) a)->t[0]) <  *(Oid*)&(((Nsrt *) b)->t[0]) ){
+    return -1;
+  }
+  return  0;
+
+}
+
+
+static const gbtree_ninfo tinfo = 
+{ 
+  gbt_t_oid,
+  sizeof(Oid),
+  gbt_oidgt,
+  gbt_oidge,
+  gbt_oideq,
+  gbt_oidle,
+  gbt_oidlt,
+  gbt_oidkey_cmp
+};
+
+
+/**************************************************
+ * Oid ops
+ **************************************************/
+
+
+Datum
+gbt_oid_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , entry , &tinfo ));
+}
+
+
+Datum
+gbt_oid_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    Oid               query = PG_GETARG_OID(1);
+    oidKEY             *kkk = (oidKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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);
+
+  Oid               res ;
+
+  *result = 0.0;
+ 
+  res     = Max(newentry->upper - origentry->upper, 0) +
+            Max(origentry->lower - newentry->lower, 0);
+
+  if ( res > 0 ){
+    *result += FLT_MIN ;
+    *result += (float) ( res / ( (double) ( res + origentry->upper - origentry->lower ) ) );
+    *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+  }
+
+  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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}

contrib/btree_gist/btree_text.c

@@ -0,0 +1,271 @@
+#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);
+
+Datum    gbt_text_compress(PG_FUNCTION_ARGS);
+Datum    gbt_bpchar_compress(PG_FUNCTION_ARGS);
+Datum    gbt_text_union(PG_FUNCTION_ARGS);
+Datum    gbt_text_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_text_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_bpchar_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_text_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_text_same(PG_FUNCTION_ARGS);
+
+
+/* define for comparison */
+
+static bool     gbt_textgt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( text_gt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_textge     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( text_ge ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_texteq     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( texteq ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_textle     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( text_le ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static bool     gbt_textlt     (const void *a, const void *b)
+{
+  return ( DatumGetBool(DirectFunctionCall2( text_lt ,PointerGetDatum( a ),PointerGetDatum( b ) ) ) );
+}
+
+static int32 gbt_textcmp ( const bytea * a , const bytea * b )
+{
+  return strcmp( VARDATA(a), VARDATA(b) );
+}
+  
+
+/*
+ * Converts data of leaf using strxfrm ( locale support )
+*/
+
+static bytea *
+gbt_text_xfrm ( bytea * leaf )
+{
+    bytea  * out = leaf;
+
+    int32  ilen = VARSIZE (leaf) - VARHDRSZ;
+    int32  olen ;
+    char   sin[ilen+1]; 
+    char   * sou = NULL;
+    memcpy ( (void*)&sin[0], (void*) VARDATA(leaf) ,ilen );
+    sin[ilen]   = '\0';
+    olen        = strxfrm ( NULL, &sin[0], 0 ) + 1;
+    sou         = palloc ( olen );
+    olen        = strxfrm ( sou , &sin[0] , olen );
+    olen       += VARHDRSZ;
+    out         = palloc ( olen + 1 );
+    out->vl_len = olen+1;
+    memcpy( (void*) VARDATA(out), sou, olen-VARHDRSZ );
+    ((char*)out)[olen]   = '\0';
+    pfree(sou);
+
+    return out;
+}
+
+
+static GBT_VARKEY * gbt_text_l2n ( GBT_VARKEY * leaf )
+{
+ 
+  GBT_VARKEY   *out = leaf ;
+  GBT_VARKEY_R r    = gbt_var_key_readable ( leaf );
+  bytea * o ;
+
+  o   = gbt_text_xfrm ( r.lower );
+  r.lower = r.upper = o;
+  out = gbt_var_key_copy ( &r , TRUE );
+  pfree(o);
+
+  return out;
+
+}
+
+
+
+
+
+static const gbtree_vinfo tinfo =
+{
+  gbt_t_text,
+  TRUE,
+  TRUE,
+  gbt_textgt,
+  gbt_textge,
+  gbt_texteq,
+  gbt_textle,
+  gbt_textlt,
+  gbt_textcmp,
+  gbt_text_l2n
+};
+
+
+
+/**************************************************
+ * Text ops
+ **************************************************/
+
+
+Datum
+gbt_text_compress (PG_FUNCTION_ARGS)
+{
+  GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+  PG_RETURN_POINTER ( gbt_var_compress( entry, &tinfo ) );
+}
+
+Datum
+gbt_bpchar_compress (PG_FUNCTION_ARGS)
+{
+
+  GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+  GISTENTRY        * retval ;
+
+  if (entry->leafkey)
+  {
+
+    Datum          d = DirectFunctionCall1 ( rtrim1, entry->key );
+    GISTENTRY * trim = palloc(sizeof(GISTENTRY));
+
+    gistentryinit(*trim, d ,
+              entry->rel, entry->page,
+              entry->offset, VARSIZE(DatumGetPointer(d)), TRUE);
+    retval = gbt_var_compress( trim , &tinfo ) ;
+
+    pfree ( trim );
+    pfree ( DatumGetPointer(d) );
+  } else
+    retval = entry;
+
+  PG_RETURN_POINTER ( retval );
+}
+
+
+
+Datum
+gbt_text_consistent(PG_FUNCTION_ARGS)
+{
+  GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+  GBT_VARKEY       *ktst  = (GBT_VARKEY   *) DatumGetPointer ( entry->key ) ;
+  GBT_VARKEY        *key  = (GBT_VARKEY   *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) );
+  void             *qtst  = ( void * ) DatumGetPointer( PG_GETARG_DATUM(1) );
+  void            *query  = ( void * ) DatumGetTextP  ( PG_GETARG_DATUM(1) );
+  StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+  bool    retval          = FALSE;
+  GBT_VARKEY_R          r =  gbt_var_key_readable ( key );
+
+  if ( GIST_LEAF(entry) )
+  {
+    retval = gbt_var_consistent( &r, query, &strategy, TRUE, &tinfo );
+  } else {
+    bytea * q = gbt_text_xfrm ( ( bytea * ) query );
+    retval    = gbt_var_consistent( &r, (void*)q, &strategy, FALSE, &tinfo );
+    if ( q != query )
+      pfree(q);
+  }
+
+  if ( ktst != key ){
+    pfree ( key );
+  }
+  if ( qtst != query ){
+    pfree ( query );
+  }
+
+  PG_RETURN_BOOL(retval);
+}
+
+
+Datum
+gbt_bpchar_consistent(PG_FUNCTION_ARGS)
+{
+  GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+  GBT_VARKEY       *ktst  = (GBT_VARKEY   *) DatumGetPointer ( entry->key ) ;
+  GBT_VARKEY        *key  = (GBT_VARKEY   *) DatumGetPointer ( PG_DETOAST_DATUM( entry->key ) );
+  void             *qtst  = ( void * ) DatumGetPointer ( PG_GETARG_DATUM(1) );
+  void            *query  = ( void * ) DatumGetPointer (PG_DETOAST_DATUM( PG_GETARG_DATUM(1) ) );
+  void             *trim  = ( void * ) DatumGetPointer ( DirectFunctionCall1 ( rtrim1, PointerGetDatum ( query ) ) ) ;
+  StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+  bool    retval          = FALSE;
+  GBT_VARKEY_R          r =  gbt_var_key_readable ( key );
+
+  if ( GIST_LEAF(entry) )
+  {
+    retval = gbt_var_consistent( &r, trim , &strategy, TRUE, &tinfo );
+  } else {
+    bytea * q = gbt_text_xfrm ( ( bytea * ) trim );
+    retval    = gbt_var_consistent( &r, (void*)q, &strategy, FALSE, &tinfo );
+    if ( q != trim )
+      pfree(q);
+  }
+
+  pfree(trim);
+
+  if ( ktst != key ){
+    pfree ( key );
+  }
+  if ( qtst != query ){
+    pfree ( query );
+  }
+  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 , &tinfo ) );
+}
+ 
+
+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, &tinfo );
+    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);
+    PG_RETURN_POINTER( gbt_var_same ( result, d1 , d2 , &tinfo ));
+}
+
+
+Datum
+gbt_text_penalty(PG_FUNCTION_ARGS)
+{
+    float      *result   = (float *)     PG_GETARG_POINTER(2);
+    GISTENTRY *      o   = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY *      n   = (GISTENTRY *) PG_GETARG_POINTER(1);
+    PG_RETURN_POINTER( gbt_var_penalty ( result ,o , n, &tinfo ) );
+}
+

contrib/btree_gist/btree_time.c

@@ -0,0 +1,248 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+#include "utils/date.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_union);
+PG_FUNCTION_INFO_V1(gbt_time_picksplit);
+PG_FUNCTION_INFO_V1(gbt_time_consistent);
+PG_FUNCTION_INFO_V1(gbt_timetz_consistent);
+PG_FUNCTION_INFO_V1(gbt_time_penalty);
+PG_FUNCTION_INFO_V1(gbt_time_same);
+
+Datum    gbt_time_compress(PG_FUNCTION_ARGS);
+Datum    gbt_timetz_compress(PG_FUNCTION_ARGS);
+Datum    gbt_time_union(PG_FUNCTION_ARGS);
+Datum    gbt_time_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_time_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_timetz_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_time_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_time_same(PG_FUNCTION_ARGS);
+
+
+static bool     gbt_timegt     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(time_gt,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) )
+  );
+}
+
+static bool     gbt_timege     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(time_ge,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) )
+  );
+}
+
+static bool     gbt_timeeq     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(time_eq,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) )
+  );
+}
+
+static bool     gbt_timele     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(time_le,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) )
+  );
+}
+
+static bool     gbt_timelt     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(time_lt,TimeADTGetDatum( *((TimeADT*)a) ), TimeADTGetDatum( *((TimeADT*)b) ) )
+  );
+}
+
+
+
+static int
+gbt_timekey_cmp(const void *a, const void *b)
+{
+  if ( gbt_timegt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){
+    return  1;
+  } else
+  if ( gbt_timelt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){
+    return -1;
+  }
+  return  0;
+}
+
+
+static const gbtree_ninfo tinfo = 
+{
+  gbt_t_time,
+  sizeof(TimeADT),
+  gbt_timegt,
+  gbt_timege,
+  gbt_timeeq,
+  gbt_timele,
+  gbt_timelt,
+  gbt_timekey_cmp
+};
+
+
+/**************************************************
+ * time ops
+ **************************************************/
+
+
+
+Datum
+gbt_time_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , 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);
+
+    retval = palloc(sizeof(GISTENTRY));
+
+    /* We are using the time + zone only to compress */
+    r->lower = r->upper = ( tz->time + tz->zone ) ; 
+    gistentryinit(*retval, PointerGetDatum(r),
+            entry->rel, entry->page,
+            entry->offset, sizeof(timeKEY), FALSE);
+  }
+  else
+    retval = entry;
+  PG_RETURN_POINTER(retval);
+}
+
+
+Datum
+gbt_time_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    TimeADT          query  = PG_GETARG_TIMEADT( 1 );
+    timeKEY            *kkk = (timeKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+Datum
+gbt_timetz_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    TimeTzADT        *query = PG_GETARG_TIMETZADT_P( 1 );
+    TimeADT             qqq = query->time + query->zone ;
+    timeKEY            *kkk = (timeKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
+}
+
+
+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 ) );
+}
+
+
+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;
+#ifdef HAVE_INT64_TIMESTAMP
+        int64      res;
+#else
+        double     res;
+#endif
+
+        intr = DatumGetIntervalP(DirectFunctionCall2(
+                  time_mi_time,
+                  TimeADTGetDatum(newentry->upper),
+                  TimeADTGetDatum(origentry->upper)));
+
+        /* see interval_larger */
+        res   = Max(intr->time + intr->month * (30 * 86400), 0);
+        pfree(intr);
+
+        intr = DatumGetIntervalP(DirectFunctionCall2(
+                  time_mi_time,
+                  TimeADTGetDatum(origentry->lower),
+                  TimeADTGetDatum(newentry->lower)));
+   
+        /* see interval_larger */
+        res  += Max(intr->time + intr->month * (30 * 86400), 0);
+        pfree(intr);
+
+        *result = 0.0;
+
+        if ( res > 0 ){
+          intr = DatumGetIntervalP(DirectFunctionCall2(
+                  time_mi_time,
+                  TimeADTGetDatum(origentry->upper),
+                  TimeADTGetDatum(origentry->lower)));
+          *result += FLT_MIN ;
+          *result += (float) ( res / ( (double) ( res + intr->time + intr->month * (30 * 86400) ) ) );
+          *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+          pfree ( intr );
+        }
+
+        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
+  ));
+}
+
+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 );
+  PG_RETURN_POINTER(result);
+}
+

contrib/btree_gist/btree_ts.c

@@ -1,288 +1,281 @@
 #include "btree_gist.h"
+#include "btree_utils_num.h"
 
-
+typedef struct
-typedef struct tskey
 {
-	Timestamp	lower;
+   Timestamp    lower;
-	Timestamp	upper;
+   Timestamp    upper;
-}	TSKEY;
+}  tsKEY;
-
-
-/*
-** tskey in/out
-*/
-PG_FUNCTION_INFO_V1(tskey_in);
-PG_FUNCTION_INFO_V1(tskey_out);
-Datum		tskey_in(PG_FUNCTION_ARGS);
-Datum		tskey_out(PG_FUNCTION_ARGS);
-
 
 /*
 ** timestamp ops
 */
-PG_FUNCTION_INFO_V1(gts_compress);
+PG_FUNCTION_INFO_V1(gbt_ts_compress);
-PG_FUNCTION_INFO_V1(gts_union);
+PG_FUNCTION_INFO_V1(gbt_tstz_compress);
-PG_FUNCTION_INFO_V1(gts_picksplit);
+PG_FUNCTION_INFO_V1(gbt_ts_union);
-PG_FUNCTION_INFO_V1(gts_consistent);
+PG_FUNCTION_INFO_V1(gbt_ts_picksplit);
-PG_FUNCTION_INFO_V1(gts_penalty);
+PG_FUNCTION_INFO_V1(gbt_ts_consistent);
-PG_FUNCTION_INFO_V1(gts_same);
+PG_FUNCTION_INFO_V1(gbt_tstz_consistent);
+PG_FUNCTION_INFO_V1(gbt_ts_penalty);
+PG_FUNCTION_INFO_V1(gbt_ts_same);
 
-Datum		gts_compress(PG_FUNCTION_ARGS);
+Datum    gbt_ts_compress(PG_FUNCTION_ARGS);
-Datum		gts_union(PG_FUNCTION_ARGS);
+Datum    gbt_tstz_compress(PG_FUNCTION_ARGS);
-Datum		gts_picksplit(PG_FUNCTION_ARGS);
+Datum    gbt_ts_union(PG_FUNCTION_ARGS);
-Datum		gts_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_ts_picksplit(PG_FUNCTION_ARGS);
-Datum		gts_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_ts_consistent(PG_FUNCTION_ARGS);
-Datum		gts_same(PG_FUNCTION_ARGS);
+Datum    gbt_tstz_consistent(PG_FUNCTION_ARGS);
+Datum    gbt_ts_penalty(PG_FUNCTION_ARGS);
+Datum    gbt_ts_same(PG_FUNCTION_ARGS);
 
-static void gts_binary_union(Datum *r1, char *r2);
-static int	tskey_cmp(const void *a, const void *b);
 
-#define TimestampGetDatumFast(X) Float8GetDatumFast(X)
+static bool     gbt_tsgt     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(timestamp_gt,PointerGetDatum( a ), PointerGetDatum( b ) )
+  );
+}
 
-/* define for comparison */
+static bool     gbt_tsge     (const void *a, const void *b)
-#define TSGE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
+{
-		timestamp_ge, \
+  return DatumGetBool( 
-		PointerGetDatum( ts1 ), \
+     DirectFunctionCall2(timestamp_ge,PointerGetDatum( a ), PointerGetDatum( b ) )
-		PointerGetDatum( ts2 ) \
+  );
-)))
+}
-#define TSGT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-		timestamp_gt, \
-		PointerGetDatum( ts1 ), \
-		PointerGetDatum( ts2 ) \
-)))
-#define TSEQ( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-		timestamp_eq, \
-		PointerGetDatum( ts1 ), \
-		PointerGetDatum( ts2 ) \
-)))
-#define TSLT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-		timestamp_lt, \
-		PointerGetDatum( ts1 ), \
-		PointerGetDatum( ts2 ) \
-)))
-#define TSLE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-		timestamp_le, \
-		PointerGetDatum( ts1 ), \
-		PointerGetDatum( ts2 ) \
-)))
 
+static bool     gbt_tseq     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(timestamp_eq,PointerGetDatum( a ), PointerGetDatum( b ) )
+  );
+}
+
+static bool     gbt_tsle     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(timestamp_le,PointerGetDatum( a ), PointerGetDatum( b ) )
+  );
+}
+
+static bool     gbt_tslt     (const void *a, const void *b)
+{
+  return DatumGetBool( 
+     DirectFunctionCall2(timestamp_lt,PointerGetDatum( a ), PointerGetDatum( b ) )
+  );
+}
+
+
+static int
+gbt_tskey_cmp(const void *a, const void *b)
+{
+  if ( gbt_tsgt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){
+    return 1;
+  } else
+  if ( gbt_tslt( (void*)&(((Nsrt *) a)->t[0]) , (void*)&(((Nsrt *) b)->t[0]) ) ){
+    return -1;
+  }
+  return  0;
+}
+
+
+static const gbtree_ninfo tinfo = 
+{ 
+  gbt_t_ts,
+  sizeof(Timestamp),
+  gbt_tsgt,
+  gbt_tsge,
+  gbt_tseq,
+  gbt_tsle,
+  gbt_tslt,
+  gbt_tskey_cmp
+};
 
 
 /**************************************************
  * timestamp ops
  **************************************************/
 
-Datum
+
-gts_compress(PG_FUNCTION_ARGS)
+
+static Timestamp * tstz_to_ts_gmt ( Timestamp * gmt, TimestampTz * ts )
 {
-	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    int         val, tz  ;
-	GISTENTRY  *retval;
 
-	if (entry->leafkey)
+    *gmt = *ts;
-	{
+    DecodeSpecial(0, "gmt", &val);
-		TSKEY	   *r = (TSKEY *) palloc(sizeof(TSKEY));
+ 
+    if ( ! TIMESTAMP_NOT_FINITE(*ts))
+    {
+      tz = val * 60;
 
-		retval = palloc(sizeof(GISTENTRY));
+#ifdef HAVE_INT64_TIMESTAMP
-		r->lower = r->upper = *(Timestamp *) (entry->key);
+      *gmt -= (tz * INT64CONST(1000000));
-		gistentryinit(*retval, PointerGetDatum(r),
+#else
-					  entry->rel, entry->page,
+      *gmt -= tz;
-					  entry->offset, sizeof(TSKEY), FALSE);
+      *gmt  = JROUND(*gmt);
-	}
+#endif
-	else
+  
-		retval = entry;
+    }
-	PG_RETURN_POINTER(retval);
+    return gmt;
+}
+
+
+
+
+Datum
+gbt_ts_compress(PG_FUNCTION_ARGS)
+{
+    GISTENTRY  *entry  = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY  *retval = NULL;
+    PG_RETURN_POINTER( gbt_num_compress( retval , 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 = *(TimestampTz *) DatumGetPointer(entry->key);
+    Timestamp   gmt ;
+
+    tstz_to_ts_gmt ( &gmt, &ts );
+
+    retval = palloc(sizeof(GISTENTRY));
+    r->lower = r->upper = gmt ;
+    gistentryinit(*retval, PointerGetDatum(r),
+         entry->rel, entry->page,
+         entry->offset, sizeof(tsKEY), FALSE);
+  }
+  else
+        retval = entry;
+
+  PG_RETURN_POINTER( retval );
+}
+
+
+Datum
+gbt_ts_consistent(PG_FUNCTION_ARGS)
+{
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    Timestamp        *query = (Timestamp *) PG_GETARG_POINTER(1);
+    tsKEY              *kkk = (tsKEY *) DatumGetPointer(entry->key);
+    GBT_NUMKEY_R        key ;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    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)
+    );
 }
 
 Datum
-gts_consistent(PG_FUNCTION_ARGS)
+gbt_tstz_consistent(PG_FUNCTION_ARGS)
 {
-	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+    GISTENTRY        *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
-	Timestamp  *query = (Timestamp *) PG_GETARG_POINTER(1);
+    TimestampTz      *query = (Timestamp *) PG_GETARG_POINTER(1);
-	StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    tsKEY              *kkk = (tsKEY *) DatumGetPointer(entry->key);
-	bool		retval;
+    GBT_NUMKEY_R        key ;
-	TSKEY	   *key;
+    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+    Timestamp    qqq  ;
+    key.lower = (GBT_NUMKEY*) &kkk->lower ;
+    key.upper = (GBT_NUMKEY*) &kkk->upper ;
+    tstz_to_ts_gmt ( &qqq, query );
 
-	/*
+    PG_RETURN_BOOL( 
-	 * * if entry is not leaf, use gbox_internal_consistent, * else use
+      gbt_num_consistent( &key, (void*)&qqq,&strategy,GIST_LEAF(entry),&tinfo)
-	 * gbox_leaf_consistent
+    );
-	 */
+}
-	if (!entry->key)
-		return FALSE;
-	key = (TSKEY *) DatumGetPointer(entry->key);
 
-	switch (strategy)
+
-	{
+Datum
-		case BTLessEqualStrategyNumber:
+gbt_ts_union(PG_FUNCTION_ARGS)
-			retval = TSGE(query, &(key->lower));
+{
-			break;
+    GistEntryVector     *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
-		case BTLessStrategyNumber:
+    void                     *out = palloc(sizeof(tsKEY));
-			if (GIST_LEAF(entry))
+    *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY);
-				retval = TSGT(query, &(key->lower));
+    PG_RETURN_POINTER( gbt_num_union ( (void*)out, entryvec, &tinfo ) );
-			else
+}
-				retval = TSGE(query, &(key->lower));
+
-			break;
+
-		case BTEqualStrategyNumber:
+Datum
-			/* in leaf page key->lower always = key->upper */
+gbt_ts_penalty(PG_FUNCTION_ARGS)
-			if (GIST_LEAF(entry))
+{
-				retval = TSEQ(query, &(key->lower));
+
-			else
+        tsKEY      *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
-				retval = (TSLE(&(key->lower), query) && TSLE(query, &(key->upper)));
+        tsKEY      *newentry  = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
-			break;
+        float      *result = (float *) PG_GETARG_POINTER(2);
-		case BTGreaterStrategyNumber:
+        Interval   *intr;
-			if (GIST_LEAF(entry))
+#ifdef HAVE_INT64_TIMESTAMP
-				retval = TSLT(query, &(key->upper));
+        int64      res;
-			else
+#else
-				retval = TSLE(query, &(key->upper));
+        double     res;
-			break;
+#endif
-		case BTGreaterEqualStrategyNumber:
+
-			retval = TSLE(query, &(key->upper));
+        intr = DatumGetIntervalP(DirectFunctionCall2( 
-			break;
+                  timestamp_mi,
-		default:
+                  TimestampGetDatum(newentry->upper),
-			retval = FALSE;
+                  TimestampGetDatum(origentry->upper)
-	}
+        ));
-	PG_RETURN_BOOL(retval);
+
+        /* see interval_larger */
+
+        res  = Max(intr->time + intr->month * (30 * 86400), 0);
+        pfree(intr);
+
+        intr = DatumGetIntervalP(DirectFunctionCall2(
+                  timestamp_mi,
+                  TimestampGetDatum(origentry->lower),
+                  TimestampGetDatum(newentry->lower)
+        ));
+
+        /* see interval_larger */
+        res += Max(intr->time + intr->month * (30 * 86400), 0);
+        pfree(intr);
+
+        *result = 0.0;
+
+        if ( res > 0 ){
+          intr = DatumGetIntervalP(DirectFunctionCall2(
+                  timestamp_mi,
+                  TimestampGetDatum(origentry->upper),
+                  TimestampGetDatum(origentry->lower)
+          ));
+          *result += FLT_MIN ;
+          *result += (float) ( res / ( (double) ( res + intr->time + intr->month * (30 * 86400) ) ) );
+          *result *= ( FLT_MAX / ( ( (GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1 ) );
+          pfree(intr);
+        }
+
+        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
+  ));
 }
 
 Datum
-gts_union(PG_FUNCTION_ARGS)
+gbt_ts_same(PG_FUNCTION_ARGS)
 {
-	GistEntryVector	   *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
+  tsKEY    *b1 = (tsKEY *) PG_GETARG_POINTER(0);
-	int			i,
+  tsKEY    *b2 = (tsKEY *) PG_GETARG_POINTER(1);
-				numranges;
+  bool     *result = (bool *) PG_GETARG_POINTER(2);
-	TSKEY	   *cur,
-			   *out = palloc(sizeof(TSKEY));
 
-	numranges = entryvec->n;
+  *result  = gbt_num_same ( (void*)b1, (void*)b2, &tinfo );
-	*(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
+  PG_RETURN_POINTER(result);
-
-	cur = (TSKEY *) DatumGetPointer((entryvec->vector[0].key));
-	out->lower = cur->lower;
-	out->upper = cur->upper;
-
-	for (i = 1; i < numranges; i++)
-	{
-		cur = (TSKEY *) DatumGetPointer((entryvec->vector[i].key));
-		if (TSGT(&out->lower, &cur->lower))
-			out->lower = cur->lower;
-		if (TSLT(&out->upper, &cur->upper))
-			out->upper = cur->upper;
-	}
-
-	PG_RETURN_POINTER(out);
 }
 
-Datum
-gts_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);
-	Interval   *intr;
-
-	intr = DatumGetIntervalP(DirectFunctionCall2(
-												 timestamp_mi,
-								  TimestampGetDatumFast(newentry->upper),
-							   TimestampGetDatumFast(origentry->upper)));
-
-	/* see interval_larger */
-	*result = Max(intr->time + intr->month * (30.0 * 86400), 0);
-	pfree(intr);
-
-	intr = DatumGetIntervalP(DirectFunctionCall2(
-												 timestamp_mi,
-								 TimestampGetDatumFast(origentry->lower),
-								TimestampGetDatumFast(newentry->lower)));
-
-	/* see interval_larger */
-	*result += Max(intr->time + intr->month * (30.0 * 86400), 0);
-	pfree(intr);
-
-	PG_RETURN_POINTER(result);
-}
-
-Datum
-gts_picksplit(PG_FUNCTION_ARGS)
-{
-	PG_RETURN_POINTER(btree_picksplit(
-									  (GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
-									  gts_binary_union,
-									  tskey_cmp
-									  ));
-}
-
-Datum
-gts_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);
-
-	if (b1 && b2)
-		*result = (TSEQ(&(b1->lower), &(b2->lower)) && TSEQ(&(b1->upper), &(b2->upper))) ? TRUE : FALSE;
-	else
-		*result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
-	PG_RETURN_POINTER(result);
-}
-
-static void
-gts_binary_union(Datum *r1, char *r2)
-{
-	TSKEY	   *b1;
-	TSKEY	   *b2 = (TSKEY *) r2;
-
-	if (!DatumGetPointer(*r1))
-	{
-		*r1 = PointerGetDatum(palloc(sizeof(TSKEY)));
-		b1 = (TSKEY *) DatumGetPointer(*r1);
-		b1->upper = b2->upper;
-		b1->lower = b2->lower;
-	}
-	else
-	{
-		b1 = (TSKEY *) DatumGetPointer(*r1);
-
-		b1->lower = (TSGT(&b1->lower, &b2->lower)) ?
-			b2->lower : b1->lower;
-		b1->upper = (TSGT(&b1->upper, &b2->upper)) ?
-			b1->upper : b2->upper;
-	}
-}
-
-static int
-tskey_cmp(const void *a, const void *b)
-{
-	return DatumGetInt32(
-						 DirectFunctionCall2(
-											 timestamp_cmp,
-			  TimestampGetDatumFast(((TSKEY *) (((RIX *) a)->r))->lower),
-			   TimestampGetDatumFast(((TSKEY *) (((RIX *) b)->r))->lower)
-											 )
-		);
-}
-
-
-/**************************************************
- * In/Out for keys, not really needed
- **************************************************/
-
-Datum
-tskey_in(PG_FUNCTION_ARGS)
-{
-	ereport(ERROR,
-			(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-			 errmsg("feature not implemented")));
-
-	PG_RETURN_POINTER(NULL);
-}
-
-Datum
-tskey_out(PG_FUNCTION_ARGS)
-{
-	ereport(ERROR,
-			(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-			 errmsg("feature not implemented")));
-
-	PG_RETURN_POINTER(NULL);
-}

contrib/btree_gist/btree_utils_num.c

@@ -0,0 +1,255 @@
+#include "btree_gist.h"
+#include "btree_utils_num.h"
+#include "utils/date.h"
+
+extern GISTENTRY *
+gbt_num_compress( GISTENTRY  *retval , GISTENTRY  *entry , const gbtree_ninfo * tinfo )
+{
+
+    if (entry->leafkey)
+    {
+
+       union {
+         int16      i2;
+         int32      i4;
+         TimeADT    ts;
+         DateADT    dt;
+       } v ;
+
+       GBT_NUMKEY  *r  = ( GBT_NUMKEY * ) palloc(2 * tinfo->size);
+       void  *leaf  = NULL;
+
+       switch ( tinfo->t )
+       {
+         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_oid  :
+           v.i4     = DatumGetObjectId(entry->key);
+           leaf     = &v.i4;
+           break;
+         case gbt_t_time  :
+           v.ts     = DatumGetTimeADT(entry->key);
+           leaf     = &v.ts;
+           break;
+         case gbt_t_date  :
+           v.dt     = DatumGetDateADT(entry->key);
+           leaf     = &v.dt;
+           break;
+         default :
+           leaf = DatumGetPointer(entry->key);
+       }
+
+       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,( 2 * tinfo->size), FALSE);
+    } else
+       retval = entry;
+
+    return retval;
+}
+
+
+
+
+/*
+** The GiST union method for numerical values
+*/
+
+extern void *
+gbt_num_union( GBT_NUMKEY * out, const GistEntryVector * entryvec, const gbtree_ninfo * tinfo )
+{
+        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 ( (*tinfo->f_gt)(o.lower, c.lower) ) /* out->lower > cur->lower */
+                     memcpy( (void* ) o.lower, (void*) c.lower, tinfo->size );
+                if ( (*tinfo->f_lt)(o.upper, c.upper) ) /* out->upper < cur->upper */
+                     memcpy( (void*) o.upper, (void*) c.upper, tinfo->size );
+        }
+
+        return out;
+}
+
+
+
+/*
+** The GiST same method for numerical values
+*/
+
+extern bool gbt_num_same ( const GBT_NUMKEY * a, const GBT_NUMKEY * b, const gbtree_ninfo * tinfo )
+{
+
+  GBT_NUMKEY_R b1, b2 ;
+
+  b1.lower = &(((GBT_NUMKEY *)a)[0]);
+  b1.upper = &(((GBT_NUMKEY *)a)[tinfo->size]);
+  b2.lower = &(((GBT_NUMKEY *)b)[0]);
+  b2.upper = &(((GBT_NUMKEY *)b)[tinfo->size]);
+
+  if (
+    (*tinfo->f_eq)( b1.lower, b2.lower) &&
+    (*tinfo->f_eq)( b1.upper, b2.upper)
+  )
+    return TRUE;
+  return FALSE;
+ 
+}
+
+
+extern void
+gbt_num_bin_union(Datum * u , GBT_NUMKEY * e , const gbtree_ninfo * tinfo )
+{
+
+  GBT_NUMKEY_R rd;
+  rd.lower = &e[0];
+  rd.upper = &e[tinfo->size];
+
+  if (!DatumGetPointer(*u))
+  {
+    *u  = PointerGetDatum(palloc(2 * tinfo->size));
+    memcpy( (void* ) &( ( (GBT_NUMKEY *) DatumGetPointer(*u) )[0] )          , (void*)rd.lower , tinfo->size );
+    memcpy( (void* ) &( ( (GBT_NUMKEY *) DatumGetPointer(*u) )[tinfo->size]) , (void*)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)((void*)ur.lower, (void*)rd.lower) )
+       memcpy( (void*) ur.lower, (void*) rd.lower, tinfo->size );
+    if ( (*tinfo->f_lt)((void*)ur.upper, (void*)rd.upper) )
+       memcpy( (void*) ur.upper, (void*) rd.upper, tinfo->size );
+  }
+
+}
+
+
+
+/*
+** The GiST consistent method
+*/
+
+extern bool  
+gbt_num_consistent(
+  const GBT_NUMKEY_R * key,
+  const void         * query,
+  const StrategyNumber * strategy,
+  bool is_leaf,
+  const gbtree_ninfo * tinfo
+)
+{
+
+        bool    retval = FALSE;
+
+        switch (*strategy)
+        {
+                case BTLessEqualStrategyNumber:
+                        retval    = (*tinfo->f_ge)(query, key->lower);
+                        break;
+                case BTLessStrategyNumber:
+                        if ( is_leaf )
+                          retval  = (*tinfo->f_gt)(query, key->lower);
+                        else 
+                          retval  = (*tinfo->f_ge)(query, key->lower);
+                        break;
+                case BTEqualStrategyNumber:
+                        if ( is_leaf )
+                           retval = (*tinfo->f_eq)(query, key->lower);
+                        else
+                           retval = (*tinfo->f_le)(key->lower, query) && (*tinfo->f_le)(query, key->upper );
+                        break;
+                case BTGreaterStrategyNumber:
+                        if ( is_leaf )
+                          retval  = (*tinfo->f_lt)(query, key->upper);
+                        else
+                          retval  = (*tinfo->f_le)(query, key->upper);
+                        break;
+                case BTGreaterEqualStrategyNumber:
+                        retval    = (*tinfo->f_le)(query, key->upper);
+                        break;
+                default:
+                        retval = FALSE;
+        }
+
+        return (retval);
+}
+
+
+
+
+GIST_SPLITVEC *
+gbt_num_picksplit( const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_ninfo * tinfo )
+{
+
+    OffsetNumber  i   ,
+
+    maxoff    = entryvec->n - 1;
+
+    Nsrt     arr[maxoff+1]  ;
+    int       nbytes  ;   
+
+    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 ( (void*) &arr[FirstOffsetNumber], maxoff-FirstOffsetNumber+1,sizeof(Nsrt), tinfo->f_cmp );
+
+    /* 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);
+        v->spl_left[v->spl_nleft]   = arr[i].i;
+        v->spl_nleft++;
+      }
+      else
+      {
+        gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo);
+        v->spl_right[v->spl_nright]   = arr[i].i;
+        v->spl_nright++;
+      }
+    }  
+
+    return v;
+
+}
+

contrib/btree_gist/btree_utils_num.h

@@ -0,0 +1,62 @@
+
+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 */
+
+  /* Methods */
+
+  bool         (*f_gt)         ( const void * , const void * );    /* greater then */
+  bool         (*f_ge)         ( const void * , const void * );    /* greater equal */
+  bool         (*f_eq)         ( const void * , const void * );    /* equal */
+  bool         (*f_le)         ( const void * , const void * );    /* less equal */
+  bool         (*f_lt)         ( const void * , const void * );    /* less then */
+  int          (*f_cmp)        ( const void * , const void * );    /* key compare function */
+} gbtree_ninfo;
+
+
+/*
+ *  Numeric btree functions
+*/
+
+extern bool            gbt_num_consistent( const GBT_NUMKEY_R * key , const void * query,
+                                const StrategyNumber * strategy , bool is_leaf,
+                                const gbtree_ninfo * tinfo );
+
+extern GIST_SPLITVEC  *gbt_num_picksplit ( const GistEntryVector *entryvec, GIST_SPLITVEC *v,
+                                const gbtree_ninfo * tinfo );
+
+extern GISTENTRY      *gbt_num_compress( GISTENTRY  *retval , GISTENTRY  *entry ,
+                                const gbtree_ninfo * tinfo );
+
+
+extern void           *gbt_num_union ( GBT_NUMKEY * out, const GistEntryVector * entryvec,
+                                const gbtree_ninfo * tinfo );
+
+extern bool            gbt_num_same ( const GBT_NUMKEY * a, const GBT_NUMKEY * b,
+                                const gbtree_ninfo * tinfo );
+
+extern void            gbt_num_bin_union(Datum * u , GBT_NUMKEY * e ,
+                                const gbtree_ninfo * tinfo );

contrib/btree_gist/btree_utils_var.c

@@ -0,0 +1,617 @@
+#include "btree_gist.h"
+#include "utils/pg_locale.h"
+#include "btree_utils_var.h"
+
+/* Returns a better readable representaion of variable key ( sets pointer ) */
+
+extern 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+(VARSIZE(r.lower))] ) ;
+        else
+          r.upper = r.lower;
+        return r;
+}
+
+
+extern GBT_VARKEY * gbt_var_key_copy ( const GBT_VARKEY_R * u , bool force_node ){
+
+        GBT_VARKEY * r = NULL;
+
+        if ( u->lower == u->upper && !force_node ){  /* leaf key mode */
+
+          r = (GBT_VARKEY *) palloc(VARSIZE(u->lower) + VARHDRSZ );
+          memcpy ( (void*) VARDATA(r), (void*) u->lower , VARSIZE(u->lower) );
+          r->vl_len = VARSIZE(u->lower) + VARHDRSZ ;
+
+        } else {                     /* node key mode  */
+
+          r = (GBT_VARKEY *) palloc(VARSIZE(u->lower) + VARSIZE(u->upper) + VARHDRSZ );
+          memcpy ( (void*) VARDATA(r)                               , (void*) u->lower , VARSIZE(u->lower) );
+          memcpy ( (void*)&(((char *)r)[VARHDRSZ+VARSIZE(u->lower)]), (void*) u->upper , VARSIZE(u->upper) );
+          r->vl_len    = VARSIZE(u->lower) + VARSIZE(u->upper) + VARHDRSZ ;
+
+        }
+        return r;
+
+}
+
+
+static GBT_VARKEY * gbt_var_leaf2node ( GBT_VARKEY * leaf, const gbtree_vinfo * tinfo )
+{
+
+  GBT_VARKEY   *out = leaf ;
+
+  if ( tinfo->f_l2n )
+  {
+    out = (*tinfo->f_l2n) (leaf);
+  }
+
+  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 )
+{
+  int32        i ;
+  int32        s = (tinfo->str)?(1):(0);
+  GBT_VARKEY_R r = gbt_var_key_readable ( node );
+  int32   t1len  = VARSIZE(r.lower) - VARHDRSZ - s;
+  int32   t2len  = VARSIZE(r.upper) - VARHDRSZ - s;
+  int32   ml     = Min(t1len,t2len) ;
+
+  char      * p1 = VARDATA(r.lower) ,
+            * p2 = VARDATA(r.upper) ;
+
+  for ( i=0 ; i<ml; i++ )
+  {
+    if ( *p1 != *p2   )
+    {
+      return i;
+    }
+    p1++;
+    p2++;
+  }
+  return ( ml );
+}
+
+
+
+/*
+ * returns true, if query matches prefix using common prefix
+*/
+
+static bool gbt_bytea_pf_match ( const bytea * pf , const bytea * query , const gbtree_vinfo * tinfo )
+{
+
+  int k  ;
+  int32     s = (tinfo->str)?(1):(0);
+  bool out    = FALSE ;
+  int32  qlen = VARSIZE(query) - VARHDRSZ - s ;
+  int32  nlen = VARSIZE(pf)    - VARHDRSZ - s ;
+  if ( nlen <= qlen )
+  {
+    char     *q  = VARDATA(query) ;
+    char     *n  = VARDATA(pf) ;
+    out = TRUE;
+    for ( k=0 ; k<nlen; k++ )
+    {
+      if ( *n != *q   ){
+        out = FALSE;
+        break;
+      }
+      if ( k < (nlen-1) )
+      {
+        q++;
+        n++;
+      }
+    }
+  }
+
+  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 (
+    gbt_bytea_pf_match ( node->lower, query , tinfo ) ||
+    gbt_bytea_pf_match ( node->upper, query , tinfo )
+  );
+
+}
+
+
+/*
+*  truncates / compresses the node key
+*/
+static GBT_VARKEY * gbt_var_node_truncate ( const GBT_VARKEY * node , int32 length , const gbtree_vinfo * tinfo )
+{
+
+  int32          s = (tinfo->str)?(1):(0);
+  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         = 0;
+
+  if (tinfo->str)
+    length++; /* because of tailing '\0' */
+
+  len1        = Min( len1, length ) ;
+  len2        = Min( len2, length ) ;
+  si          = 3*VARHDRSZ + len1 + len2;
+  out         = (GBT_VARKEY *) palloc ( si );
+  out->vl_len = si;
+  memcpy ( (void*) &(((char*)out)[VARHDRSZ])         , (void*)r.lower, len1+VARHDRSZ-s );
+  memcpy ( (void*) &(((char*)out)[2*VARHDRSZ+len1])  , (void*)r.upper, len2+VARHDRSZ-s );
+
+  if (tinfo->str)
+  {
+    ((char*)out)[2*VARHDRSZ+len1-1]               = '\0';
+    ((char*)out)[3*VARHDRSZ+len1+len2-1]          = '\0';
+  }
+  *((int32*)&(((char*)out)[VARHDRSZ]))          = len1 + VARHDRSZ;
+  *((int32*)&(((char*)out)[2*VARHDRSZ+len1]))   = len2 + VARHDRSZ;
+
+  return out;
+}
+
+
+
+extern void
+gbt_var_bin_union ( Datum * u , GBT_VARKEY * e , const gbtree_vinfo * tinfo )         
+{
+
+     GBT_VARKEY   * nk = NULL;
+     GBT_VARKEY  * tmp = NULL;
+     GBT_VARKEY_R   nr ;
+     GBT_VARKEY_R   eo = gbt_var_key_readable ( e );
+
+
+     if ( eo.lower == eo.upper ) /* leaf */
+     {
+        tmp = gbt_var_leaf2node ( e , tinfo );
+        if ( tmp != e )
+          eo  = gbt_var_key_readable ( tmp );
+     }
+
+     if ( DatumGetPointer(*u))
+     {
+
+       GBT_VARKEY_R ro  = gbt_var_key_readable ( ( GBT_VARKEY *) DatumGetPointer (*u) );
+
+       if ( (*tinfo->f_cmp) ( (bytea*)ro.lower, (bytea*)eo.lower ) > 0 ) {
+         nr.lower = eo.lower;
+         nr.upper = ro.upper;
+         nk       = gbt_var_key_copy ( &nr, TRUE );
+       }
+       if ( (*tinfo->f_cmp) ( (bytea*)ro.upper, (bytea*)eo.upper ) < 0 ) {
+         nr.upper = eo.upper;
+         nr.lower = ro.lower;
+         nk       = gbt_var_key_copy ( &nr, TRUE );
+       }
+       if ( nk )
+       {
+         pfree( DatumGetPointer (*u) );
+         *u = PointerGetDatum(nk);
+       }
+
+
+
+     }
+     else
+     {
+       nr.lower = eo.lower;
+       nr.upper = eo.upper;
+       *u  = PointerGetDatum( gbt_var_key_copy ( &nr, TRUE ) );
+     }
+
+     if ( tmp && tmp != e )
+       pfree ( tmp );
+
+}
+
+
+
+extern GISTENTRY  *
+gbt_var_compress ( GISTENTRY *entry , const gbtree_vinfo * tinfo )
+{
+
+        GISTENTRY * retval;
+
+        if (entry->leafkey)
+        {
+            GBT_VARKEY * r = NULL;
+            bytea * tstd = ( bytea * ) DatumGetPointer ( entry->key );                        /* toasted   */
+            bytea * leaf = ( bytea * ) DatumGetPointer ( PG_DETOAST_DATUM ( entry->key ) );   /* untoasted */
+            GBT_VARKEY_R  u ;
+
+            u.lower     = u.upper = leaf;           
+            r           = gbt_var_key_copy ( &u , FALSE );
+
+            if ( tstd != leaf ){
+              pfree(leaf);
+            }
+            retval      = palloc(sizeof(GISTENTRY));
+            gistentryinit(*retval, PointerGetDatum(r),
+                   entry->rel, entry->page,
+                   entry->offset, VARSIZE(r), TRUE);
+        } else {
+          retval = entry;
+
+
+        }
+
+        return (retval);
+}
+
+
+
+extern GBT_VARKEY *
+gbt_var_union ( const GistEntryVector * entryvec , int32  * size , const gbtree_vinfo * tinfo )
+{
+
+    int        i = 0,
+    numranges = entryvec->n;
+    GBT_VARKEY   *cur,
+                 *tst=NULL;
+    Datum         out;
+    GBT_VARKEY_R   rk;
+
+    *size = sizeof(GBT_VARKEY);
+
+    tst = (GBT_VARKEY *) DatumGetPointer((entryvec->vector[0].key));
+    cur = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[0].key)));
+    rk  = gbt_var_key_readable ( cur );
+    out = PointerGetDatum ( gbt_var_key_copy( &rk, TRUE ) );
+    if ( tst != cur ) pfree ( cur );
+
+    for (i = 1; i < numranges; i++)
+    {
+       tst = (GBT_VARKEY *) DatumGetPointer((entryvec->vector[i].key));
+       cur = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[i].key)));
+       gbt_var_bin_union ( &out , cur , tinfo );
+       if ( tst != cur ) pfree ( cur );
+    }
+
+
+    /* 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 ) ;
+
+      pfree ( DatumGetPointer(out) );
+      out  = PointerGetDatum ( trc );
+    }
+
+    return ( (GBT_VARKEY *) DatumGetPointer ( out ) );
+}
+
+
+extern bool gbt_var_same ( bool * result, const Datum d1 , const Datum d2 , const gbtree_vinfo * tinfo ){
+
+        GBT_VARKEY      *tst1   = (GBT_VARKEY *) DatumGetPointer(d1);
+        GBT_VARKEY      *t1     = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(d1) );
+        GBT_VARKEY      *tst2   = (GBT_VARKEY *) DatumGetPointer(d2);
+        GBT_VARKEY      *t2     = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(d2) );
+        GBT_VARKEY_R r1, r2;
+        r1 = gbt_var_key_readable ( t1 );
+        r2 = gbt_var_key_readable ( t2 );
+
+        if (t1 && t2){
+                *result = ( ( (*tinfo->f_cmp ) ( (bytea*)r1.lower, (bytea*)r2.lower) == 0 
+                              && (*tinfo->f_cmp) ( (bytea*)r1.upper, (bytea*)r2.upper) == 0 ) ? TRUE : FALSE );
+        } else
+                *result = (t1 == NULL && t2 == NULL) ? TRUE : FALSE;
+
+        if ( tst1 != t1 ) pfree (t1);
+        if ( tst2 != t2 ) pfree (t2);
+
+        PG_RETURN_POINTER(result);
+}
+
+
+
+extern float *
+gbt_var_penalty ( float * res , const GISTENTRY * o , const GISTENTRY * n, const gbtree_vinfo * tinfo )
+{
+
+   GBT_VARKEY    *orgt  = (GBT_VARKEY *) DatumGetPointer(o->key);
+   GBT_VARKEY    *orge  = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(o->key) );
+   GBT_VARKEY    *newt  = (GBT_VARKEY *) DatumGetPointer(n->key);
+   GBT_VARKEY    *newe  = (GBT_VARKEY *) DatumGetPointer( PG_DETOAST_DATUM(n->key) );
+   GBT_VARKEY_R  ok , nk;
+   GBT_VARKEY      *tmp = NULL;
+   int32              s = (tinfo->str)?(1):(0);
+
+   *res = 0.0;
+
+   nk  = gbt_var_key_readable ( newe );
+   if ( nk.lower == nk.upper ) /* leaf */
+   {
+      tmp = gbt_var_leaf2node    ( newe , tinfo );
+      if ( tmp != newe )
+        nk  = gbt_var_key_readable ( tmp  );
+   }
+   ok  = gbt_var_key_readable ( orge );
+
+   if ( ( VARSIZE(ok.lower) - VARHDRSZ ) == s && ( VARSIZE(ok.upper) - VARHDRSZ ) == s )
+   {
+     *res = 0.0;
+   } else
+   if ( ! (
+     (
+        ( (*tinfo->f_cmp) (nk.lower, ok.lower)>=0 || gbt_bytea_pf_match(ok.lower, nk.lower, tinfo ) ) &&
+        ( (*tinfo->f_cmp) (nk.upper, ok.upper)<=0 || gbt_bytea_pf_match(ok.upper, nk.upper, tinfo ) )
+     )
+   ) )
+   {
+      Datum     d = PointerGetDatum (0);
+      double dres = 0.0;
+      int32 ol, ul;
+
+      gbt_var_bin_union ( &d , orge , tinfo );
+      ol = gbt_var_node_cp_len ( ( GBT_VARKEY *) DatumGetPointer(d), tinfo );
+      gbt_var_bin_union ( &d , newe , tinfo );
+      ul = gbt_var_node_cp_len ( ( GBT_VARKEY *) DatumGetPointer(d), tinfo );
+
+      if ( ul < ol ) {
+        dres = ( ol-ul ) ; /* lost of common prefix len */
+      } else {
+        GBT_VARKEY_R uk = gbt_var_key_readable ( ( GBT_VARKEY *) DatumGetPointer(d) );
+        if ( tinfo->str )
+        {
+          dres = ( VARDATA(ok.lower)[ul]-VARDATA(uk.lower)[ul] ) +
+                 ( VARDATA(uk.upper)[ul]-VARDATA(ok.upper)[ul] );
+        } else {
+          char tmp[4];
+          tmp[0] = ( ( VARSIZE(ok.lower) - VARHDRSZ ) == ul  )?(CHAR_MIN):(VARDATA(ok.lower)[ul]);
+          tmp[1] = ( ( VARSIZE(uk.lower) - VARHDRSZ ) == ul  )?(CHAR_MIN):(VARDATA(uk.lower)[ul]);
+          tmp[2] = ( ( VARSIZE(ok.upper) - VARHDRSZ ) == ul  )?(CHAR_MIN):(VARDATA(ok.upper)[ul]);
+          tmp[3] = ( ( VARSIZE(uk.upper) - VARHDRSZ ) == ul  )?(CHAR_MIN):(VARDATA(uk.upper)[ul]);
+          dres = ( tmp[0] - tmp[1] ) +
+                 ( tmp[3] - tmp[2] );
+        }
+        dres /= 256.0;
+      }
+      pfree ( DatumGetPointer(d) );
+
+      *res += FLT_MIN ;
+      *res += (float) ( dres / ( (double) ( ol +1 ) ) );
+      *res *= ( FLT_MAX / ( o->rel->rd_att->natts + 1 ) );
+
+   }
+
+   if ( tmp && tmp != newe )
+     pfree (tmp);
+
+   if ( newe != newt ){
+     pfree ( newe );
+   }
+
+   if ( orge != orgt ){
+     pfree ( orge );
+   }
+   return res ;
+
+}
+
+
+static int32 gbt_vsrt_cmp ( const Vsrt * a , const Vsrt * b , const gbtree_vinfo * tinfo )
+{
+  GBT_VARKEY_R    ar  = gbt_var_key_readable ( a->t );
+  GBT_VARKEY_R    br  = gbt_var_key_readable ( b->t );
+  return (*tinfo->f_cmp) ( ar.lower, br.lower );
+}
+
+
+
+extern GIST_SPLITVEC *
+gbt_var_picksplit( const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_vinfo * tinfo )
+{
+
+    OffsetNumber  i   ,
+            maxoff    = entryvec->n - 1;
+
+    Vsrt     arr[maxoff+1]  ;
+    int       pfrcntr = 0 ,
+              svcntr  = 0 , 
+              nbytes  ;   
+    char        * tst ,
+                * cur ;
+
+    char       **pfr = NULL ;
+    GBT_VARKEY **sv  = NULL;
+
+    static int cmp (const void *a, const void *b ){
+      return gbt_vsrt_cmp ((Vsrt *) a , (Vsrt *) b , tinfo );
+    }
+
+    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; 
+
+    pfr = palloc ( sizeof ( GBT_VARKEY* ) * (maxoff+1) );
+    sv  = palloc ( sizeof ( bytea * ) * (maxoff+1) );
+
+    /* Sort entries */
+
+    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+    {
+      GBT_VARKEY_R ro;
+      tst = (char *) DatumGetPointer((entryvec->vector[i].key));
+      cur = (char *) DatumGetPointer(PG_DETOAST_DATUM((entryvec->vector[i].key)));
+      if ( tst != cur ){
+        pfr[pfrcntr] = cur ;
+        pfrcntr++;
+      }
+      ro = gbt_var_key_readable( ( GBT_VARKEY *) cur );
+      if ( ro.lower == ro.upper ) /* leaf */
+      {
+        sv[svcntr] = gbt_var_leaf2node ( ( GBT_VARKEY *) cur , tinfo );
+        arr[i].t   = sv[svcntr];
+        if ( sv[svcntr] != ( GBT_VARKEY *) cur )
+          svcntr++;
+      } else {
+        arr[i].t = ( GBT_VARKEY *) cur;
+      }
+      arr[i].i = i;
+    }
+
+    /* sort */
+    qsort ( (void*) &arr[FirstOffsetNumber], maxoff-FirstOffsetNumber+1,sizeof(Vsrt), cmp );
+
+
+    /* 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, tinfo);
+        v->spl_left[v->spl_nleft]   = arr[i].i;
+        v->spl_nleft++;
+      }
+      else
+      {
+        gbt_var_bin_union(&v->spl_rdatum, arr[i].t, tinfo);
+        v->spl_right[v->spl_nright]   = arr[i].i;
+        v->spl_nright++;
+      }
+    }  
+
+    /* Free detoasted keys */
+    for ( i=0 ; i<pfrcntr; i++ ){
+      pfree( pfr[i] );
+    }
+
+    /* Free strxfrm'ed leafs */
+    for ( i=0 ; i<svcntr; i++ ){
+      pfree( sv[i] );
+    }
+
+    if ( pfr )
+    {
+      pfree (pfr);
+    }
+
+    if ( sv )
+    {
+      pfree (sv);
+    }
+
+    /* 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 ) ;
+      pfree( DatumGetPointer(v->spl_ldatum) );
+      pfree( DatumGetPointer(v->spl_rdatum) );
+      v->spl_ldatum = PointerGetDatum ( dl );
+      v->spl_rdatum = PointerGetDatum ( dr );
+
+    }
+
+    return v;
+
+}
+
+
+
+
+
+/*
+** The GiST consistent method
+*/
+
+extern bool  
+gbt_var_consistent( 
+  GBT_VARKEY_R * key,
+  const void * query,
+  const StrategyNumber * strategy,
+  bool is_leaf,
+  const gbtree_vinfo * tinfo
+)
+{
+        bool    retval = FALSE;
+
+        switch (*strategy)
+        {
+                case BTLessEqualStrategyNumber:
+                        if ( is_leaf )
+                                retval = (*tinfo->f_ge)(query, (void*) key->lower);
+                        else
+                                retval = (*tinfo->f_cmp)((bytea*) query, key->lower) >= 0
+                                           || gbt_var_node_pf_match( key ,query, tinfo );
+                        break;
+                case BTLessStrategyNumber:
+                        if ( is_leaf )
+                                retval = (*tinfo->f_gt)(query, (void*) key->lower);
+                        else
+                                retval = (*tinfo->f_cmp)((bytea*)query, key->lower) >= 0
+                                           || gbt_var_node_pf_match( key, query , tinfo );
+                        break;
+                case BTEqualStrategyNumber:
+                        if ( is_leaf )
+                                retval = (*tinfo->f_eq)(query, (void*) key->lower);
+                        else
+                                retval = ( 
+                                           (
+                                             (*tinfo->f_cmp) (key->lower,(bytea*) query)<=0 &&
+                                             (*tinfo->f_cmp) ((bytea*)query, (void*) key->upper)<=0 
+                                           ) || gbt_var_node_pf_match( key, query, tinfo ) 
+                                         );
+                        break;
+                case BTGreaterStrategyNumber:
+                        if ( is_leaf )
+                                retval = (*tinfo->f_lt)(query, (void*) key->upper);
+                        else
+                                retval = (*tinfo->f_cmp)((bytea*)query, key->upper)<=0 
+                                           || gbt_var_node_pf_match( key, query, tinfo );
+                        break;
+                case BTGreaterEqualStrategyNumber:
+                        if ( is_leaf )
+                                retval = (*tinfo->f_le)(query, (void*) key->upper);
+                        else
+                                retval = (*tinfo->f_cmp)((bytea*) query, key->upper)<=0 
+                                           || gbt_var_node_pf_match( key, query, tinfo );
+                        break;
+                default:
+                        retval = FALSE;
+        }
+
+        return (retval);
+}

contrib/btree_gist/btree_utils_var.h

@@ -0,0 +1,67 @@
+
+/* Variable length key */
+typedef bytea GBT_VARKEY;
+
+/* Better readable key */
+typedef struct
+{
+  bytea * lower, * upper;
+} GBT_VARKEY_R;
+
+/* used for key sorting */
+typedef struct
+{
+  int          i ;
+  GBT_VARKEY * t ;
+} Vsrt ;
+
+/*
+  type description
+*/
+
+
+typedef struct
+{
+
+  /* Attribs */
+
+  enum gbtree_type t       ;  /* data type */
+  bool             str     ;  /* true, if string ( else binary ) */
+  bool             trnc    ;  /* truncate (=compress) key */
+
+  /* Methods */
+
+  bool         (*f_gt)         ( const   void * , const   void * );    /* greater then */
+  bool         (*f_ge)         ( const   void * , const   void * );    /* greater equal */
+  bool         (*f_eq)         ( const   void * , const   void * );    /* equal */
+  bool         (*f_le)         ( const   void * , const   void * );    /* less equal */
+  bool         (*f_lt)         ( const   void * , const   void * );    /* less then */
+  int32        (*f_cmp)        ( const  bytea * , const  bytea * );    /* node compare */
+  GBT_VARKEY*  (*f_l2n)        ( GBT_VARKEY * );                       /* 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, bool force_node );
+
+extern GISTENTRY        *gbt_var_compress ( GISTENTRY *entry , const gbtree_vinfo * tinfo );
+
+extern GBT_VARKEY       *gbt_var_union ( const GistEntryVector * entryvec , int32  * size ,
+                                const gbtree_vinfo * tinfo );
+
+extern bool              gbt_var_same ( bool * result, const Datum d1 , const Datum d2 ,
+                                const gbtree_vinfo * tinfo );
+
+extern float            *gbt_var_penalty ( float * res , const GISTENTRY * o , const GISTENTRY * n,
+                                const gbtree_vinfo * tinfo );
+
+extern bool              gbt_var_consistent( GBT_VARKEY_R * key , const void * query,
+                                const StrategyNumber * strategy , bool is_leaf,
+                                const gbtree_vinfo * tinfo );
+
+extern GIST_SPLITVEC    *gbt_var_picksplit ( const GistEntryVector *entryvec, GIST_SPLITVEC *v,
+                                const gbtree_vinfo * tinfo );
+extern void              gbt_var_bin_union ( Datum * u , GBT_VARKEY * e ,
+                                const gbtree_vinfo * tinfo );

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

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

contrib/btree_gist/data/char.data

@@ -0,0 +1,534 @@
+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

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

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

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

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

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

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

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

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

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

contrib/btree_gist/data/numeric.data

@@ -0,0 +1,11 @@
+-1890.000000000000000000000000000000000000000000000000000000000000000000000000001
+-1889.999999999999999999999999999999999999999999999999999999999999999999999999999
+123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567891
+123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567892
+10000
+0
+0
+0
+NaN
+NaN

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

contrib/btree_gist/data/timestamp.data

@@ -0,0 +1,600 @@
+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
+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
+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
+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

contrib/btree_gist/data/timestamptz.data

@@ -0,0 +1,600 @@
+\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
+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
+\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
+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

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

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

contrib/btree_gist/expected/bit.out

@@ -0,0 +1,66 @@
+-- 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)
+

contrib/btree_gist/expected/btree_gist.out

@@ -1,102 +0,0 @@
---
--- first, define the datatype.  Turn off echoing so that expected file
--- does not depend on contents of btree_gist.sql.
---
-\set ECHO none
-psql:btree_gist.sql:8: NOTICE:  type "int2key" is not yet defined
-DETAIL:  Creating a shell type definition.
-psql:btree_gist.sql:13: NOTICE:  argument type int2key is only a shell
-psql:btree_gist.sql:25: NOTICE:  type "int4key" is not yet defined
-DETAIL:  Creating a shell type definition.
-psql:btree_gist.sql:30: NOTICE:  argument type int4key is only a shell
-psql:btree_gist.sql:42: NOTICE:  type "int8key" is not yet defined
-DETAIL:  Creating a shell type definition.
-psql:btree_gist.sql:47: NOTICE:  argument type int8key is only a shell
-psql:btree_gist.sql:59: NOTICE:  type "float4key" is not yet defined
-DETAIL:  Creating a shell type definition.
-psql:btree_gist.sql:64: NOTICE:  argument type float4key is only a shell
-psql:btree_gist.sql:77: NOTICE:  type "float8key" is not yet defined
-DETAIL:  Creating a shell type definition.
-psql:btree_gist.sql:82: NOTICE:  argument type float8key is only a shell
-psql:btree_gist.sql:392: NOTICE:  type "tskey" is not yet defined
-DETAIL:  Creating a shell type definition.
-psql:btree_gist.sql:397: NOTICE:  argument type tskey is only a shell
-CREATE TABLE int4tmp (b int4);
-\copy int4tmp from 'data/test_btree.data'
-CREATE TABLE int8tmp (b int8);
-\copy int8tmp from 'data/test_btree.data'
-CREATE TABLE float4tmp (b float4);
-\copy float4tmp from 'data/test_btree.data'
-CREATE TABLE float8tmp (b float8);
-\copy float8tmp from 'data/test_btree.data'
-CREATE TABLE tstmp ( t timestamp without time zone );
-\copy tstmp from 'data/test_btree_ts.data'
--- without idx
-SELECT count(*) FROM int4tmp WHERE b <=10;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM int8tmp WHERE b <=10;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM float4tmp WHERE b <=10;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM float8tmp WHERE b <=10;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM tstmp WHERE t < '2001-05-29 08:33:09';
- count 
--------
-    66
-(1 row)
-
--- create idx
-CREATE INDEX aaaidx ON int4tmp USING gist ( b );
-CREATE INDEX bbbidx ON int8tmp USING gist ( b );
-CREATE INDEX cccidx ON float4tmp USING gist ( b );
-CREATE INDEX dddidx ON float8tmp USING gist ( b );
-CREATE INDEX tsidx ON tstmp USING gist ( t );
---with idx
-SET enable_seqscan=off;
-SELECT count(*) FROM int4tmp WHERE b <=10::int4;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM int8tmp WHERE b <=10::int8;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM float4tmp WHERE b <=10::float4;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM float8tmp WHERE b <=10::float8;
- count 
--------
-    11
-(1 row)
-
-SELECT count(*) FROM tstmp WHERE t < '2001-05-29 08:33:09';
- count 
--------
-    66
-(1 row)
-

contrib/btree_gist/expected/cash.out

@@ -0,0 +1,66 @@
+-- money check
+CREATE TABLE moneytmp (a money) WITH OIDS;
+\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)
+
+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)
+

contrib/btree_gist/expected/char.out

@@ -0,0 +1,66 @@
+-- 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 
+-------
+   121
+(1 row)
+
+SELECT count(*) FROM chartmp WHERE a <=  '31b0'::char(32);
+ count 
+-------
+   122
+(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 
+-------
+   121
+(1 row)
+
+SELECT count(*) FROM chartmp WHERE a <=  '31b0'::char(32);
+ count 
+-------
+   122
+(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)
+

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)
+

contrib/btree_gist/expected/date.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/float4.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/float8.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/inet.out

@@ -0,0 +1,66 @@
+-- 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)
+

contrib/btree_gist/expected/init.out

@@ -0,0 +1,20 @@
+--
+-- first, define the datatype.  Turn off echoing so that expected file
+-- does not depend on contents of btree_gist.sql.
+--
+\set ECHO none
+psql:btree_gist.sql:7: NOTICE:  type "gbtreekey4" is not yet defined
+DETAIL:  Creating a shell type definition.
+psql:btree_gist.sql:12: NOTICE:  argument type gbtreekey4 is only a shell
+psql:btree_gist.sql:23: NOTICE:  type "gbtreekey8" is not yet defined
+DETAIL:  Creating a shell type definition.
+psql:btree_gist.sql:28: NOTICE:  argument type gbtreekey8 is only a shell
+psql:btree_gist.sql:39: NOTICE:  type "gbtreekey16" is not yet defined
+DETAIL:  Creating a shell type definition.
+psql:btree_gist.sql:44: NOTICE:  argument type gbtreekey16 is only a shell
+psql:btree_gist.sql:55: NOTICE:  type "gbtreekey24" is not yet defined
+DETAIL:  Creating a shell type definition.
+psql:btree_gist.sql:60: NOTICE:  argument type gbtreekey24 is only a shell
+psql:btree_gist.sql:71: NOTICE:  type "gbtreekey_var" is not yet defined
+DETAIL:  Creating a shell type definition.
+psql:btree_gist.sql:76: NOTICE:  argument type gbtreekey_var is only a shell

contrib/btree_gist/expected/int2.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/int4.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/int8.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/interval.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/macaddr.out

@@ -0,0 +1,66 @@
+-- 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)
+

contrib/btree_gist/expected/numeric.out

@@ -0,0 +1,188 @@
+-- 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)
+

contrib/btree_gist/expected/oid.out

@@ -0,0 +1,64 @@
+-- oid check
+SET enable_seqscan=on;
+SELECT count(*) FROM moneytmp WHERE oid <  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   372
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid <= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   373
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid  = ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+     1
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid >= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   228
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid >  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   227
+(1 row)
+
+CREATE INDEX oididx ON moneytmp USING gist ( oid );
+SET enable_seqscan=off;
+SELECT count(*) FROM moneytmp WHERE oid <  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   372
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid <= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   373
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid  = ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+     1
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid >= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   228
+(1 row)
+
+SELECT count(*) FROM moneytmp WHERE oid >  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+ count 
+-------
+   227
+(1 row)
+

contrib/btree_gist/expected/time.out

@@ -0,0 +1,66 @@
+-- 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)
+
+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)
+

contrib/btree_gist/expected/timestamp.out

@@ -0,0 +1,66 @@
+-- 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 
+-------
+   270
+(1 row)
+
+SELECT count(*) FROM timestamptmp WHERE a <= '2004-10-26 08:55:08';
+ count 
+-------
+   271
+(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 
+-------
+   274
+(1 row)
+
+SELECT count(*) FROM timestamptmp WHERE a >  '2004-10-26 08:55:08';
+ count 
+-------
+   273
+(1 row)
+
+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 
+-------
+   270
+(1 row)
+
+SELECT count(*) FROM timestamptmp WHERE a <= '2004-10-26 08:55:08'::timestamp;
+ count 
+-------
+   271
+(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 
+-------
+   274
+(1 row)
+
+SELECT count(*) FROM timestamptmp WHERE a >  '2004-10-26 08:55:08'::timestamp;
+ count 
+-------
+   273
+(1 row)
+

contrib/btree_gist/expected/timestamptz.out

@@ -0,0 +1,186 @@
+-- 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 
+-------
+   385
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+3';
+ count 
+-------
+   386
+(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 
+-------
+   146
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a >  '2018-12-18 10:59:54 GMT+3';
+ count 
+-------
+   145
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <  '2018-12-18 10:59:54 GMT+2';
+ count 
+-------
+   385
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+2';
+ count 
+-------
+   385
+(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 
+-------
+   146
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a >  '2018-12-18 10:59:54 GMT+2';
+ count 
+-------
+   146
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <  '2018-12-18 10:59:54 GMT+4';
+ count 
+-------
+   386
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+4';
+ count 
+-------
+   386
+(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 
+-------
+   145
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a >  '2018-12-18 10:59:54 GMT+4';
+ count 
+-------
+   145
+(1 row)
+
+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 
+-------
+   385
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+3'::timestamptz;
+ count 
+-------
+   386
+(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 
+-------
+   146
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a >  '2018-12-18 10:59:54 GMT+3'::timestamptz;
+ count 
+-------
+   145
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <  '2018-12-18 10:59:54 GMT+2'::timestamptz;
+ count 
+-------
+   385
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+2'::timestamptz;
+ count 
+-------
+   385
+(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 
+-------
+   146
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a >  '2018-12-18 10:59:54 GMT+2'::timestamptz;
+ count 
+-------
+   146
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <  '2018-12-18 10:59:54 GMT+4'::timestamptz;
+ count 
+-------
+   386
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a <= '2018-12-18 10:59:54 GMT+4'::timestamptz;
+ count 
+-------
+   386
+(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 
+-------
+   145
+(1 row)
+
+SELECT count(*) FROM timestamptztmp WHERE a >  '2018-12-18 10:59:54 GMT+4'::timestamptz;
+ count 
+-------
+   145
+(1 row)
+

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)
+

contrib/btree_gist/expected/varbit.out

@@ -0,0 +1,66 @@
+-- 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)
+

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 
+-------
+   121
+(1 row)
+
+SELECT count(*) FROM vchartmp WHERE a <=  '31b0'::varchar(32);
+ count 
+-------
+   122
+(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 
+-------
+   121
+(1 row)
+
+SELECT count(*) FROM vchartmp WHERE a <=  '31b0'::varchar(32);
+ count 
+-------
+   122
+(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)
+

contrib/btree_gist/sql/bit.sql

@@ -0,0 +1,31 @@
+-- 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';

contrib/btree_gist/sql/btree_gist.sql

@@ -1,66 +0,0 @@
---
--- first, define the datatype.  Turn off echoing so that expected file
--- does not depend on contents of btree_gist.sql.
---
-\set ECHO none
-\i btree_gist.sql
-\set ECHO all
-
-CREATE TABLE int4tmp (b int4);
-
-\copy int4tmp from 'data/test_btree.data'
-
-CREATE TABLE int8tmp (b int8);
-
-\copy int8tmp from 'data/test_btree.data'
-
-CREATE TABLE float4tmp (b float4);
-
-\copy float4tmp from 'data/test_btree.data'
-
-CREATE TABLE float8tmp (b float8);
-
-\copy float8tmp from 'data/test_btree.data'
-
-CREATE TABLE tstmp ( t timestamp without time zone );
-
-\copy tstmp from 'data/test_btree_ts.data'
-
--- without idx
-
-SELECT count(*) FROM int4tmp WHERE b <=10;
-
-SELECT count(*) FROM int8tmp WHERE b <=10;
-
-SELECT count(*) FROM float4tmp WHERE b <=10;
-
-SELECT count(*) FROM float8tmp WHERE b <=10;
-
-SELECT count(*) FROM tstmp WHERE t < '2001-05-29 08:33:09';
-
--- create idx
-
-CREATE INDEX aaaidx ON int4tmp USING gist ( b );
-
-CREATE INDEX bbbidx ON int8tmp USING gist ( b );
-
-CREATE INDEX cccidx ON float4tmp USING gist ( b );
-
-CREATE INDEX dddidx ON float8tmp USING gist ( b );
-
-CREATE INDEX tsidx ON tstmp USING gist ( t );
-
---with idx
-
-SET enable_seqscan=off;
-
-SELECT count(*) FROM int4tmp WHERE b <=10::int4;
-
-SELECT count(*) FROM int8tmp WHERE b <=10::int8;
-
-SELECT count(*) FROM float4tmp WHERE b <=10::float4;
-
-SELECT count(*) FROM float8tmp WHERE b <=10::float8;
-
-SELECT count(*) FROM tstmp WHERE t < '2001-05-29 08:33:09';
-

contrib/btree_gist/sql/cash.sql

@@ -0,0 +1,31 @@
+-- money check
+
+CREATE TABLE moneytmp (a money) WITH OIDS;
+
+\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';
+
+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;

contrib/btree_gist/sql/char.sql

@@ -0,0 +1,31 @@
+-- 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);

contrib/btree_gist/sql/cidr.sql

@@ -0,0 +1,31 @@
+-- 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;
+

contrib/btree_gist/sql/date.sql

@@ -0,0 +1,32 @@
+-- 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';
+
+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;
+

contrib/btree_gist/sql/float4.sql

@@ -0,0 +1,31 @@
+-- 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;
+
+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;

contrib/btree_gist/sql/float8.sql

@@ -0,0 +1,31 @@
+-- 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;
+
+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;

contrib/btree_gist/sql/inet.sql

@@ -0,0 +1,32 @@
+-- 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;
+

contrib/btree_gist/sql/init.sql

@@ -0,0 +1,7 @@
+--
+-- first, define the datatype.  Turn off echoing so that expected file
+-- does not depend on contents of btree_gist.sql.
+--
+\set ECHO none
+\i btree_gist.sql
+\set ECHO all

contrib/btree_gist/sql/int2.sql

@@ -0,0 +1,32 @@
+-- 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;
+
+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;
+

contrib/btree_gist/sql/int4.sql

@@ -0,0 +1,32 @@
+-- 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;
+
+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;
+

contrib/btree_gist/sql/int8.sql

@@ -0,0 +1,32 @@
+-- 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;
+
+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;
+

contrib/btree_gist/sql/interval.sql

@@ -0,0 +1,32 @@
+-- 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';
+
+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;
+

contrib/btree_gist/sql/macaddr.sql

@@ -0,0 +1,32 @@
+-- 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;
+

contrib/btree_gist/sql/numeric.sql

@@ -0,0 +1,77 @@
+-- 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 ;

contrib/btree_gist/sql/oid.sql

@@ -0,0 +1,27 @@
+-- oid check
+
+SET enable_seqscan=on;
+
+SELECT count(*) FROM moneytmp WHERE oid <  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid <= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid  = ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid >= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid >  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+CREATE INDEX oididx ON moneytmp USING gist ( oid );
+
+SET enable_seqscan=off;
+
+SELECT count(*) FROM moneytmp WHERE oid <  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid <= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid  = ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid >= ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );
+
+SELECT count(*) FROM moneytmp WHERE oid >  ( SELECT oid FROM moneytmp WHERE a  = '22649.64' );

contrib/btree_gist/sql/time.sql

@@ -0,0 +1,32 @@
+-- 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';
+
+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;
+

contrib/btree_gist/sql/timestamp.sql

@@ -0,0 +1,32 @@
+-- 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';
+
+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;
+

contrib/btree_gist/sql/timestamptz.sql

@@ -0,0 +1,76 @@
+-- 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';
+
+
+
+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;

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;

contrib/btree_gist/sql/varbit.sql

@@ -0,0 +1,31 @@
+-- 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;

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);