From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Wed, 25 Mar 2009 23:20:01 +0000 (+0000)
Subject: Add btree_gin contrib module.
X-Git-Tag: REL8_4_BETA1~135
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=9151e1bb06df025a4c8837c611c5775e2227b9bf;p=postgresql

Add btree_gin contrib module.

Teodor Sigaev and Oleg Bartunov
---

diff --git a/contrib/Makefile b/contrib/Makefile
index 4b1d2ae95d..e840c8ce6a 100644
--- a/contrib/Makefile
+++ b/contrib/Makefile
@@ -1,4 +1,4 @@
-# $PostgreSQL: pgsql/contrib/Makefile,v 1.86 2009/01/04 22:19:59 tgl Exp $
+# $PostgreSQL: pgsql/contrib/Makefile,v 1.87 2009/03/25 23:20:01 tgl Exp $
 
 subdir = contrib
 top_builddir = ..
@@ -7,6 +7,7 @@ include $(top_builddir)/src/Makefile.global
 WANTED_DIRS = \
 		adminpack	\
 		auto_explain	\
+		btree_gin	\
 		btree_gist	\
 		chkpass		\
 		citext		\
diff --git a/contrib/README b/contrib/README
index 7d258d4b2f..1ae49adc70 100644
--- a/contrib/README
+++ b/contrib/README
@@ -32,6 +32,10 @@ auto_explain -
 	Log EXPLAIN output for long-running queries
 	by Takahiro Itagaki <itagaki.takahiro@oss.ntt.co.jp>
 
+btree_gin -
+	Support for emulating BTREE indexing in GIN
+	by Oleg Bartunov <oleg@sai.msu.su> and Teodor Sigaev <teodor@sigaev.ru>
+
 btree_gist -
 	Support for emulating BTREE indexing in GiST
 	by Oleg Bartunov <oleg@sai.msu.su> and Teodor Sigaev <teodor@sigaev.ru>
diff --git a/contrib/btree_gin/Makefile b/contrib/btree_gin/Makefile
new file mode 100644
index 0000000000..e6b6394c23
--- /dev/null
+++ b/contrib/btree_gin/Makefile
@@ -0,0 +1,22 @@
+# $PostgreSQL: pgsql/contrib/btree_gin/Makefile,v 1.1 2009/03/25 23:20:01 tgl Exp $
+
+MODULE_big = btree_gin
+OBJS = btree_gin.o 
+
+DATA_built = btree_gin.sql
+DATA = uninstall_btree_gin.sql
+REGRESS = install_btree_gin int2 int4 int8 float4 float8 money oid \
+	timestamp timestamptz time timetz date interval \
+	macaddr inet cidr text varchar char bytea bit varbit \
+	numeric
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = contrib/btree_gin
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/contrib/btree_gin/btree_gin.c b/contrib/btree_gin/btree_gin.c
new file mode 100644
index 0000000000..164eeb8d3b
--- /dev/null
+++ b/contrib/btree_gin/btree_gin.c
@@ -0,0 +1,420 @@
+/*
+ * $PostgreSQL: pgsql/contrib/btree_gin/btree_gin.c,v 1.1 2009/03/25 23:20:01 tgl Exp $
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "fmgr.h"
+#include "access/skey.h"
+#include "utils/builtins.h"
+#include "utils/cash.h"
+#include "utils/date.h"
+#include "utils/inet.h"
+#include "utils/numeric.h"
+#include "utils/timestamp.h"
+#include "utils/varbit.h"
+
+PG_MODULE_MAGIC;
+
+typedef struct TypeInfo
+{
+    bool    is_varlena;
+	Datum   (*leftmostvalue)(void);
+	Datum   (*typecmp)(FunctionCallInfo);
+} TypeInfo;
+
+typedef struct QueryInfo
+{
+	StrategyNumber		strategy;
+	Datum				datum;
+} QueryInfo;
+
+#define  GIN_EXTRACT_VALUE(type)											\
+PG_FUNCTION_INFO_V1(gin_extract_value_##type);								\
+Datum       gin_extract_value_##type(PG_FUNCTION_ARGS);						\
+Datum																		\
+gin_extract_value_##type(PG_FUNCTION_ARGS)									\
+{																			\
+	Datum		datum = PG_GETARG_DATUM(0);									\
+	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);					\
+	Datum	   *entries = (Datum *) palloc(sizeof(Datum));					\
+																			\
+	if ( TypeInfo_##type.is_varlena )										\
+		datum = PointerGetDatum(PG_DETOAST_DATUM(datum));					\
+	entries[0] = datum;														\
+	*nentries = 1;															\
+																			\
+	PG_RETURN_POINTER(entries);												\
+}
+
+/*
+ * For BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, and
+ * BTEqualStrategyNumber we want to start the index scan at the
+ * supplied query datum, and work forward. For BTLessStrategyNumber
+ * and BTLessEqualStrategyNumber, we need to start at the leftmost
+ * key, and work forward until the supplied query datum (which must be
+ * sent along inside the QueryInfo structure).
+ */
+
+#define GIN_EXTRACT_QUERY(type)												\
+PG_FUNCTION_INFO_V1(gin_extract_query_##type);								\
+Datum       gin_extract_query_##type(PG_FUNCTION_ARGS);						\
+Datum																		\
+gin_extract_query_##type(PG_FUNCTION_ARGS)									\
+{																			\
+	Datum		datum = PG_GETARG_DATUM(0);									\
+	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);					\
+	StrategyNumber strategy = PG_GETARG_UINT16(2);							\
+	bool	  **partialmatch = (bool **) PG_GETARG_POINTER(3);				\
+	Pointer	  **extra_data = (Pointer **) PG_GETARG_POINTER(4);				\
+	Datum	   *entries = (Datum *) palloc(sizeof(Datum));					\
+	QueryInfo  *data = (QueryInfo *) palloc(sizeof(QueryInfo));				\
+	bool	   *ptr_partialmatch;											\
+																			\
+	*nentries = 1;															\
+	ptr_partialmatch = *partialmatch = (bool *) palloc(sizeof(bool));		\
+	*ptr_partialmatch = false;												\
+	if ( TypeInfo_##type.is_varlena )										\
+		datum = PointerGetDatum(PG_DETOAST_DATUM(datum));					\
+	data->strategy = strategy;												\
+	data->datum = datum;													\
+	*extra_data = (Pointer *) palloc(sizeof(Pointer));						\
+	**extra_data = (Pointer) data;											\
+																			\
+	switch (strategy)														\
+	{																		\
+		case BTLessStrategyNumber:											\
+		case BTLessEqualStrategyNumber:										\
+			entries[0] = TypeInfo_##type.leftmostvalue();					\
+			*ptr_partialmatch = true;										\
+			break;															\
+		case BTGreaterEqualStrategyNumber:									\
+		case BTGreaterStrategyNumber:										\
+			*ptr_partialmatch = true;										\
+		case BTEqualStrategyNumber:											\
+			entries[0] = datum;												\
+			break;															\
+		default:															\
+			elog(ERROR, "unrecognized strategy number: %d", strategy);		\
+	}																		\
+																			\
+	PG_RETURN_POINTER(entries);												\
+}
+
+/*
+ * Datum a is a value from extract_query method and for BTLess*
+ * strategy it is a left-most value.  So, use original datum from QueryInfo
+ * to decide to stop scanning or not.  Datum b is always from index.
+ */
+#define GIN_COMPARE_PREFIX(type)											\
+PG_FUNCTION_INFO_V1(gin_compare_prefix_##type);								\
+Datum       gin_compare_prefix_##type(PG_FUNCTION_ARGS);					\
+Datum																		\
+gin_compare_prefix_##type(PG_FUNCTION_ARGS)									\
+{																			\
+	Datum		a = PG_GETARG_DATUM(0);										\
+	Datum		b = PG_GETARG_DATUM(1);										\
+	QueryInfo  *data = (QueryInfo *) PG_GETARG_POINTER(3);					\
+	int32		res,														\
+				cmp;														\
+																			\
+	cmp = DatumGetInt32(DirectFunctionCall2(								\
+				TypeInfo_##type.typecmp, 									\
+				(data->strategy == BTLessStrategyNumber || 					\
+				 data->strategy == BTLessEqualStrategyNumber)				\
+				 ? data->datum : a, 										\
+				b));														\
+																			\
+	switch (data->strategy)													\
+	{																		\
+		case BTLessStrategyNumber:											\
+			/* If original datum > indexed one then return match */			\
+			if (cmp > 0)													\
+				res = 0;													\
+			else															\
+				res = 1;													\
+			break;															\
+		case BTLessEqualStrategyNumber:										\
+			/* The same except equality */									\
+			if (cmp >= 0)													\
+				res = 0;													\
+			else															\
+				res = 1;													\
+			break;															\
+		case BTEqualStrategyNumber:											\
+			if (cmp != 0)													\
+				res = 1;													\
+			else															\
+				res = 0;													\
+			break;															\
+		case BTGreaterEqualStrategyNumber:									\
+			/* If original datum <= indexed one then return match */		\
+			if (cmp <= 0)													\
+				res = 0;													\
+			else															\
+				res = 1;													\
+			break;															\
+		case BTGreaterStrategyNumber:										\
+			/* If original datum <= indexed one then return match */		\
+			/* If original datum == indexed one then continue scan */		\
+			if (cmp < 0)													\
+				res = 0;													\
+			else if (cmp == 0)												\
+				res = -1;													\
+			else															\
+				res = 1;													\
+			break;															\
+		default:															\
+			elog(ERROR, "unrecognized strategy number: %d", 				\
+				 data->strategy);											\
+			res = 0;														\
+	}																		\
+																			\
+	PG_RETURN_INT32(res);													\
+}
+
+#define GIN_SUPPORT(type)			\
+	GIN_EXTRACT_VALUE(type)			\
+	GIN_EXTRACT_QUERY(type)			\
+	GIN_COMPARE_PREFIX(type)
+
+
+PG_FUNCTION_INFO_V1(gin_btree_consistent);
+Datum       gin_btree_consistent(PG_FUNCTION_ARGS);
+Datum
+gin_btree_consistent(PG_FUNCTION_ARGS)
+{
+	bool       *recheck = (bool *) PG_GETARG_POINTER(5);
+
+	*recheck = false;
+	PG_RETURN_BOOL(true);
+}
+
+static Datum
+leftmostvalue_int2(void)
+{
+	return Int16GetDatum(SHRT_MIN);
+}
+static TypeInfo TypeInfo_int2 = {false, leftmostvalue_int2, btint2cmp};
+GIN_SUPPORT(int2)
+
+static Datum
+leftmostvalue_int4(void)
+{
+	return Int32GetDatum(INT_MIN);
+}
+static TypeInfo TypeInfo_int4 = {false, leftmostvalue_int4, btint4cmp};
+GIN_SUPPORT(int4)
+
+static Datum
+leftmostvalue_int8(void)
+{
+	/*
+	 * Use sequence's definition to keep compatibility.
+	 * Another way may make a problem with INT64_IS_BUSTED
+	 */
+	return Int64GetDatum(SEQ_MINVALUE);
+}
+static TypeInfo TypeInfo_int8 = {false, leftmostvalue_int8, btint8cmp};
+GIN_SUPPORT(int8)
+
+static Datum
+leftmostvalue_float4(void)
+{
+	return Float4GetDatum(-get_float4_infinity());
+}
+static TypeInfo TypeInfo_float4 = {false, leftmostvalue_float4, btfloat4cmp};
+GIN_SUPPORT(float4)
+
+static Datum
+leftmostvalue_float8(void)
+{
+	return Float8GetDatum(-get_float8_infinity());
+}
+static TypeInfo TypeInfo_float8 = {false, leftmostvalue_float8, btfloat8cmp};
+GIN_SUPPORT(float8)
+
+static Datum
+leftmostvalue_money(void)
+{
+	/*
+	 * Use sequence's definition to keep compatibility.
+	 * Another way may make a problem with INT64_IS_BUSTED
+	 */
+	return Int64GetDatum(SEQ_MINVALUE);
+}
+static TypeInfo TypeInfo_money = {false, leftmostvalue_money, cash_cmp};
+GIN_SUPPORT(money)
+
+static Datum
+leftmostvalue_oid(void)
+{
+	return ObjectIdGetDatum(0);
+}
+static TypeInfo TypeInfo_oid = {false, leftmostvalue_oid, btoidcmp};
+GIN_SUPPORT(oid)
+
+static Datum
+leftmostvalue_timestamp(void)
+{
+	return TimestampGetDatum(DT_NOBEGIN);
+}
+static TypeInfo TypeInfo_timestamp = {false, leftmostvalue_timestamp, timestamp_cmp};
+GIN_SUPPORT(timestamp)
+
+static TypeInfo TypeInfo_timestamptz = {false, leftmostvalue_timestamp, timestamp_cmp};
+GIN_SUPPORT(timestamptz)
+
+static Datum
+leftmostvalue_time(void)
+{
+	return TimeADTGetDatum(0);
+}
+static TypeInfo TypeInfo_time = {false, leftmostvalue_time, time_cmp};
+GIN_SUPPORT(time)
+
+static Datum
+leftmostvalue_timetz(void)
+{
+	TimeTzADT	*v = palloc(sizeof(TimeTzADT));
+
+	v->time = 0;
+	v->zone = -24*3600; /* XXX is that true? */
+
+	return TimeTzADTPGetDatum(v);
+}
+static TypeInfo TypeInfo_timetz = {false, leftmostvalue_timetz, timetz_cmp};
+GIN_SUPPORT(timetz)
+
+static Datum
+leftmostvalue_date(void)
+{
+	return DateADTGetDatum(DATEVAL_NOBEGIN);
+}
+static TypeInfo TypeInfo_date = {false, leftmostvalue_date, date_cmp};
+GIN_SUPPORT(date)
+
+static Datum
+leftmostvalue_interval(void)
+{
+	Interval *v = palloc(sizeof(Interval));
+
+	v->time = DT_NOBEGIN;
+	v->day = 0;
+	v->month = 0;
+	return IntervalPGetDatum(v);
+}
+static TypeInfo TypeInfo_interval = {false, leftmostvalue_interval, interval_cmp};
+GIN_SUPPORT(interval)
+
+static Datum
+leftmostvalue_macaddr(void)
+{
+	macaddr *v = palloc0(sizeof(macaddr));
+
+	return MacaddrPGetDatum(v);
+}
+static TypeInfo TypeInfo_macaddr = {false, leftmostvalue_macaddr, macaddr_cmp};
+GIN_SUPPORT(macaddr)
+
+static Datum
+leftmostvalue_inet(void)
+{
+	return DirectFunctionCall3(inet_in,
+							   CStringGetDatum("0.0.0.0/0"),
+							   ObjectIdGetDatum(0),
+							   Int32GetDatum(-1));
+}
+static TypeInfo TypeInfo_inet = {true, leftmostvalue_inet, network_cmp};
+GIN_SUPPORT(inet)
+
+static TypeInfo TypeInfo_cidr = {true, leftmostvalue_inet, network_cmp};
+GIN_SUPPORT(cidr)
+
+static Datum
+leftmostvalue_text(void)
+{
+	return PointerGetDatum(cstring_to_text_with_len("", 0));
+}
+static TypeInfo TypeInfo_text = {true, leftmostvalue_text, bttextcmp};
+GIN_SUPPORT(text)
+
+static Datum
+leftmostvalue_char(void)
+{
+	return CharGetDatum(SCHAR_MIN);
+}
+static TypeInfo TypeInfo_char = {false, leftmostvalue_char, btcharcmp};
+GIN_SUPPORT(char)
+
+static TypeInfo TypeInfo_bytea = {true, leftmostvalue_text, byteacmp};
+GIN_SUPPORT(bytea)
+
+static Datum
+leftmostvalue_bit(void)
+{
+	return DirectFunctionCall3(bit_in,
+							   CStringGetDatum(""),
+							   ObjectIdGetDatum(0),
+							   Int32GetDatum(-1));
+}
+static TypeInfo TypeInfo_bit = {true, leftmostvalue_bit, bitcmp};
+GIN_SUPPORT(bit)
+
+static Datum
+leftmostvalue_varbit(void)
+{
+	return DirectFunctionCall3(varbit_in,
+							   CStringGetDatum(""),
+							   ObjectIdGetDatum(0),
+							   Int32GetDatum(-1));
+}
+static TypeInfo TypeInfo_varbit = {true, leftmostvalue_varbit, bitcmp};
+GIN_SUPPORT(varbit)
+
+/*
+ * Numeric type hasn't applicable left-most value, so NULL
+ * is used for that. NULL will never be an argument for a C-level
+ * numeric function except gin_numeric_cmp and it will not be stored
+ * somewhere and it could not be returned in any user SQL query.
+ */
+
+#define NUMERIC_IS_LEFTMOST(x)	((x) == NULL)
+
+PG_FUNCTION_INFO_V1(gin_numeric_cmp);
+Datum       gin_numeric_cmp(PG_FUNCTION_ARGS);
+
+Datum
+gin_numeric_cmp(PG_FUNCTION_ARGS)
+{
+	Numeric	a = (Numeric)PG_GETARG_POINTER(0);
+	Numeric	b = (Numeric)PG_GETARG_POINTER(1);
+	int		res = 0;
+
+	if ( NUMERIC_IS_LEFTMOST(a) )
+	{
+		res = ( NUMERIC_IS_LEFTMOST(b) ) ? 0 : -1;
+	}
+	else if ( NUMERIC_IS_LEFTMOST(b) )
+	{
+		res = 1;
+	}
+	else
+	{
+		res = DatumGetInt32(DirectFunctionCall2(numeric_cmp,
+												NumericGetDatum(a),
+												NumericGetDatum(b)));
+	}
+
+	PG_RETURN_INT32(res);
+}
+
+static Datum
+leftmostvalue_numeric(void)
+{
+	return PointerGetDatum(NULL);
+}
+
+static TypeInfo TypeInfo_numeric = {true, leftmostvalue_numeric, gin_numeric_cmp};
+GIN_SUPPORT(numeric)
diff --git a/contrib/btree_gin/btree_gin.sql.in b/contrib/btree_gin/btree_gin.sql.in
new file mode 100644
index 0000000000..bc7ec3bbcb
--- /dev/null
+++ b/contrib/btree_gin/btree_gin.sql.in
@@ -0,0 +1,689 @@
+/* $PostgreSQL: pgsql/contrib/btree_gin/btree_gin.sql.in,v 1.1 2009/03/25 23:20:01 tgl Exp $ */
+
+-- Adjust this setting to control where the objects get created.
+SET search_path = public;
+
+CREATE OR REPLACE FUNCTION gin_btree_consistent(internal, int2, anyelement, int4, internal, internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_int2(int2, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_int2(int2, int2, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_int2(int2, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS int2_ops
+DEFAULT FOR TYPE int2 USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       btint2cmp(int2,int2),
+    FUNCTION        2       gin_extract_value_int2(int2, internal),
+    FUNCTION        3       gin_extract_query_int2(int2, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_int2(int2,int2,int2, internal),
+STORAGE         int2;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_int4(int4, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_int4(int4, int4, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_int4(int4, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS int4_ops
+DEFAULT FOR TYPE int4 USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       btint4cmp(int4,int4),
+    FUNCTION        2       gin_extract_value_int4(int4, internal),
+    FUNCTION        3       gin_extract_query_int4(int4, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_int4(int4,int4,int2, internal),
+STORAGE         int4;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_int8(int8, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_int8(int8, int8, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_int8(int8, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS int8_ops
+DEFAULT FOR TYPE int8 USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       btint8cmp(int8,int8),
+    FUNCTION        2       gin_extract_value_int8(int8, internal),
+    FUNCTION        3       gin_extract_query_int8(int8, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_int8(int8,int8,int2, internal),
+STORAGE         int8;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_float4(float4, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_float4(float4, float4, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_float4(float4, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS float4_ops
+DEFAULT FOR TYPE float4 USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       btfloat4cmp(float4,float4),
+    FUNCTION        2       gin_extract_value_float4(float4, internal),
+    FUNCTION        3       gin_extract_query_float4(float4, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_float4(float4,float4,int2, internal),
+STORAGE         float4;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_float8(float8, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_float8(float8, float8, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_float8(float8, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS float8_ops
+DEFAULT FOR TYPE float8 USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       btfloat8cmp(float8,float8),
+    FUNCTION        2       gin_extract_value_float8(float8, internal),
+    FUNCTION        3       gin_extract_query_float8(float8, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_float8(float8,float8,int2, internal),
+STORAGE         float8;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_money(money, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_money(money, money, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_money(money, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS money_ops
+DEFAULT FOR TYPE money USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       cash_cmp(money,money),
+    FUNCTION        2       gin_extract_value_money(money, internal),
+    FUNCTION        3       gin_extract_query_money(money, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_money(money,money,int2, internal),
+STORAGE         money;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_oid(oid, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_oid(oid, oid, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_oid(oid, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS oid_ops
+DEFAULT FOR TYPE oid USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       btoidcmp(oid,oid),
+    FUNCTION        2       gin_extract_value_oid(oid, internal),
+    FUNCTION        3       gin_extract_query_oid(oid, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_oid(oid,oid,int2, internal),
+STORAGE         oid;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_timestamp(timestamp, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_timestamp(timestamp, timestamp, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_timestamp(timestamp, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS timestamp_ops
+DEFAULT FOR TYPE timestamp USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       timestamp_cmp(timestamp,timestamp),
+    FUNCTION        2       gin_extract_value_timestamp(timestamp, internal),
+    FUNCTION        3       gin_extract_query_timestamp(timestamp, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_timestamp(timestamp,timestamp,int2, internal),
+STORAGE         timestamp;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_timestamptz(timestamptz, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_timestamptz(timestamptz, timestamptz, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_timestamptz(timestamptz, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS timestamptz_ops
+DEFAULT FOR TYPE timestamptz USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       timestamptz_cmp(timestamptz,timestamptz),
+    FUNCTION        2       gin_extract_value_timestamptz(timestamptz, internal),
+    FUNCTION        3       gin_extract_query_timestamptz(timestamptz, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_timestamptz(timestamptz,timestamptz,int2, internal),
+STORAGE         timestamptz;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_time(time, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_time(time, time, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_time(time, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS time_ops
+DEFAULT FOR TYPE time USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       time_cmp(time,time),
+    FUNCTION        2       gin_extract_value_time(time, internal),
+    FUNCTION        3       gin_extract_query_time(time, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_time(time,time,int2, internal),
+STORAGE         time;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_timetz(timetz, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_timetz(timetz, timetz, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_timetz(timetz, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS timetz_ops
+DEFAULT FOR TYPE timetz USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       timetz_cmp(timetz,timetz),
+    FUNCTION        2       gin_extract_value_timetz(timetz, internal),
+    FUNCTION        3       gin_extract_query_timetz(timetz, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_timetz(timetz,timetz,int2, internal),
+STORAGE         timetz;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_date(date, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_date(date, date, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_date(date, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS date_ops
+DEFAULT FOR TYPE date USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       date_cmp(date,date),
+    FUNCTION        2       gin_extract_value_date(date, internal),
+    FUNCTION        3       gin_extract_query_date(date, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_date(date,date,int2, internal),
+STORAGE         date;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_interval(interval, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_interval(interval, interval, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_interval(interval, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS interval_ops
+DEFAULT FOR TYPE interval USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       interval_cmp(interval,interval),
+    FUNCTION        2       gin_extract_value_interval(interval, internal),
+    FUNCTION        3       gin_extract_query_interval(interval, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_interval(interval,interval,int2, internal),
+STORAGE         interval;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_macaddr(macaddr, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_macaddr(macaddr, macaddr, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_macaddr(macaddr, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS macaddr_ops
+DEFAULT FOR TYPE macaddr USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       macaddr_cmp(macaddr,macaddr),
+    FUNCTION        2       gin_extract_value_macaddr(macaddr, internal),
+    FUNCTION        3       gin_extract_query_macaddr(macaddr, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_macaddr(macaddr,macaddr,int2, internal),
+STORAGE         macaddr;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_inet(inet, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_inet(inet, inet, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_inet(inet, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS inet_ops
+DEFAULT FOR TYPE inet USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       network_cmp(inet,inet),
+    FUNCTION        2       gin_extract_value_inet(inet, internal),
+    FUNCTION        3       gin_extract_query_inet(inet, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_inet(inet,inet,int2, internal),
+STORAGE         inet;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_cidr(cidr, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_cidr(cidr, cidr, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_cidr(cidr, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS cidr_ops
+DEFAULT FOR TYPE cidr USING gin
+AS
+    OPERATOR        1       <(inet,inet),
+    OPERATOR        2       <=(inet,inet),
+    OPERATOR        3       =(inet,inet),
+    OPERATOR        4       >=(inet,inet),
+    OPERATOR        5       >(inet,inet),
+    FUNCTION        1       network_cmp(inet,inet),
+    FUNCTION        2       gin_extract_value_cidr(cidr, internal),
+    FUNCTION        3       gin_extract_query_cidr(cidr, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_cidr(cidr,cidr,int2, internal),
+STORAGE         cidr;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_text(text, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_text(text, text, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_text(text, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS text_ops
+DEFAULT FOR TYPE text USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       bttextcmp(text,text),
+    FUNCTION        2       gin_extract_value_text(text, internal),
+    FUNCTION        3       gin_extract_query_text(text, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_text(text,text,int2, internal),
+STORAGE         text;
+
+CREATE OPERATOR CLASS varchar_ops
+DEFAULT FOR TYPE varchar USING gin
+AS
+    OPERATOR        1       <(text,text),
+    OPERATOR        2       <=(text,text),
+    OPERATOR        3       =(text,text),
+    OPERATOR        4       >=(text,text),
+    OPERATOR        5       >(text,text),
+    FUNCTION        1       bttextcmp(text,text),
+    FUNCTION        2       gin_extract_value_text(text, internal),
+    FUNCTION        3       gin_extract_query_text(text, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_text(text,text,int2, internal),
+STORAGE         varchar;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_char("char", internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_char("char", "char", int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_char("char", internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS char_ops
+DEFAULT FOR TYPE "char" USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       btcharcmp("char","char"),
+    FUNCTION        2       gin_extract_value_char("char", internal),
+    FUNCTION        3       gin_extract_query_char("char", internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_char("char","char",int2, internal),
+STORAGE         "char";
+
+CREATE OR REPLACE FUNCTION gin_extract_value_bytea(bytea, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_bytea(bytea, bytea, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_bytea(bytea, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS bytea_ops
+DEFAULT FOR TYPE bytea USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       byteacmp(bytea,bytea),
+    FUNCTION        2       gin_extract_value_bytea(bytea, internal),
+    FUNCTION        3       gin_extract_query_bytea(bytea, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_bytea(bytea,bytea,int2, internal),
+STORAGE         bytea;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_bit(bit, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_bit(bit, bit, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_bit(bit, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS bit_ops
+DEFAULT FOR TYPE bit USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       bitcmp(bit,bit),
+    FUNCTION        2       gin_extract_value_bit(bit, internal),
+    FUNCTION        3       gin_extract_query_bit(bit, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_bit(bit,bit,int2, internal),
+STORAGE         bit;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_varbit(varbit, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_varbit(varbit, varbit, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_varbit(varbit, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS varbit_ops
+DEFAULT FOR TYPE varbit USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       varbitcmp(varbit,varbit),
+    FUNCTION        2       gin_extract_value_varbit(varbit, internal),
+    FUNCTION        3       gin_extract_query_varbit(varbit, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_varbit(varbit,varbit,int2, internal),
+STORAGE         varbit;
+
+CREATE OR REPLACE FUNCTION gin_extract_value_numeric(numeric, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_compare_prefix_numeric(numeric, numeric, int2, internal)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_extract_query_numeric(numeric, internal, int2, internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION gin_numeric_cmp(numeric, numeric)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR CLASS numeric_ops
+DEFAULT FOR TYPE numeric USING gin
+AS
+    OPERATOR        1       <,
+    OPERATOR        2       <=,
+    OPERATOR        3       =,
+    OPERATOR        4       >=,
+    OPERATOR        5       >,
+    FUNCTION        1       gin_numeric_cmp(numeric,numeric),
+    FUNCTION        2       gin_extract_value_numeric(numeric, internal),
+    FUNCTION        3       gin_extract_query_numeric(numeric, internal, int2, internal, internal),
+    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
+    FUNCTION        5       gin_compare_prefix_numeric(numeric,numeric,int2, internal),
+STORAGE         numeric;
diff --git a/contrib/btree_gin/expected/bit.out b/contrib/btree_gin/expected/bit.out
new file mode 100644
index 0000000000..3c00a2071e
--- /dev/null
+++ b/contrib/btree_gin/expected/bit.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_bit (
+	i bit(3)
+);
+INSERT INTO test_bit VALUES ('001'),('010'),('011'),('100'),('101'),('110');
+CREATE INDEX idx_bit ON test_bit USING gin (i);
+SELECT * FROM test_bit WHERE i<'100'::bit(3) ORDER BY i;
+  i  
+-----
+ 001
+ 010
+ 011
+(3 rows)
+
+SELECT * FROM test_bit WHERE i<='100'::bit(3) ORDER BY i;
+  i  
+-----
+ 001
+ 010
+ 011
+ 100
+(4 rows)
+
+SELECT * FROM test_bit WHERE i='100'::bit(3) ORDER BY i;
+  i  
+-----
+ 100
+(1 row)
+
+SELECT * FROM test_bit WHERE i>='100'::bit(3) ORDER BY i;
+  i  
+-----
+ 100
+ 101
+ 110
+(3 rows)
+
+SELECT * FROM test_bit WHERE i>'100'::bit(3) ORDER BY i;
+  i  
+-----
+ 101
+ 110
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/bytea.out b/contrib/btree_gin/expected/bytea.out
new file mode 100644
index 0000000000..7b19149205
--- /dev/null
+++ b/contrib/btree_gin/expected/bytea.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_bytea (
+	i bytea
+);
+INSERT INTO test_bytea VALUES ('aaa'),('a'),('abc'),('abb'),('axy'),('xyz');
+CREATE INDEX idx_bytea ON test_bytea USING gin (i);
+SELECT * FROM test_bytea WHERE i<'abc'::bytea ORDER BY i;
+  i  
+-----
+ a
+ aaa
+ abb
+(3 rows)
+
+SELECT * FROM test_bytea WHERE i<='abc'::bytea ORDER BY i;
+  i  
+-----
+ a
+ aaa
+ abb
+ abc
+(4 rows)
+
+SELECT * FROM test_bytea WHERE i='abc'::bytea ORDER BY i;
+  i  
+-----
+ abc
+(1 row)
+
+SELECT * FROM test_bytea WHERE i>='abc'::bytea ORDER BY i;
+  i  
+-----
+ abc
+ axy
+ xyz
+(3 rows)
+
+SELECT * FROM test_bytea WHERE i>'abc'::bytea ORDER BY i;
+  i  
+-----
+ axy
+ xyz
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/char.out b/contrib/btree_gin/expected/char.out
new file mode 100644
index 0000000000..09e0315de0
--- /dev/null
+++ b/contrib/btree_gin/expected/char.out
@@ -0,0 +1,37 @@
+set enable_seqscan=off;
+CREATE TABLE test_char (
+	i "char"
+);
+INSERT INTO test_char VALUES ('a'),('b'),('c'),('d'),('e'),('f');
+CREATE INDEX idx_char ON test_char USING gin (i);
+SELECT * FROM test_char WHERE i<'d'::"char" ORDER BY i;
+ i 
+---
+(0 rows)
+
+SELECT * FROM test_char WHERE i<='d'::"char" ORDER BY i;
+ i 
+---
+(0 rows)
+
+SELECT * FROM test_char WHERE i='d'::"char" ORDER BY i;
+ i 
+---
+ d
+(1 row)
+
+SELECT * FROM test_char WHERE i>='d'::"char" ORDER BY i;
+ i 
+---
+ d
+ e
+ f
+(3 rows)
+
+SELECT * FROM test_char WHERE i>'d'::"char" ORDER BY i;
+ i 
+---
+ e
+ f
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/cidr.out b/contrib/btree_gin/expected/cidr.out
new file mode 100644
index 0000000000..28ff9195b1
--- /dev/null
+++ b/contrib/btree_gin/expected/cidr.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_cidr (
+	i cidr
+);
+INSERT INTO test_cidr VALUES 
+	( '1.2.3.4' ),
+	( '1.2.4.4' ),
+	( '1.2.5.4' ),
+	( '1.2.6.4' ),
+	( '1.2.7.4' ),
+	( '1.2.8.4' )
+;
+CREATE INDEX idx_cidr ON test_cidr USING gin (i);
+SELECT * FROM test_cidr WHERE i<'1.2.6.4'::cidr ORDER BY i;
+     i      
+------------
+ 1.2.3.4/32
+ 1.2.4.4/32
+ 1.2.5.4/32
+(3 rows)
+
+SELECT * FROM test_cidr WHERE i<='1.2.6.4'::cidr ORDER BY i;
+     i      
+------------
+ 1.2.3.4/32
+ 1.2.4.4/32
+ 1.2.5.4/32
+ 1.2.6.4/32
+(4 rows)
+
+SELECT * FROM test_cidr WHERE i='1.2.6.4'::cidr ORDER BY i;
+     i      
+------------
+ 1.2.6.4/32
+(1 row)
+
+SELECT * FROM test_cidr WHERE i>='1.2.6.4'::cidr ORDER BY i;
+     i      
+------------
+ 1.2.6.4/32
+ 1.2.7.4/32
+ 1.2.8.4/32
+(3 rows)
+
+SELECT * FROM test_cidr WHERE i>'1.2.6.4'::cidr ORDER BY i;
+     i      
+------------
+ 1.2.7.4/32
+ 1.2.8.4/32
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/date.out b/contrib/btree_gin/expected/date.out
new file mode 100644
index 0000000000..8da6ee4843
--- /dev/null
+++ b/contrib/btree_gin/expected/date.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_date (
+	i date
+);
+INSERT INTO test_date VALUES 
+	( '2004-10-23' ),
+	( '2004-10-24' ),
+	( '2004-10-25' ),
+	( '2004-10-26' ),
+	( '2004-10-27' ),
+	( '2004-10-28' )
+;
+CREATE INDEX idx_date ON test_date USING gin (i);
+SELECT * FROM test_date WHERE i<'2004-10-26'::date ORDER BY i;
+     i      
+------------
+ 10-23-2004
+ 10-24-2004
+ 10-25-2004
+(3 rows)
+
+SELECT * FROM test_date WHERE i<='2004-10-26'::date ORDER BY i;
+     i      
+------------
+ 10-23-2004
+ 10-24-2004
+ 10-25-2004
+ 10-26-2004
+(4 rows)
+
+SELECT * FROM test_date WHERE i='2004-10-26'::date ORDER BY i;
+     i      
+------------
+ 10-26-2004
+(1 row)
+
+SELECT * FROM test_date WHERE i>='2004-10-26'::date ORDER BY i;
+     i      
+------------
+ 10-26-2004
+ 10-27-2004
+ 10-28-2004
+(3 rows)
+
+SELECT * FROM test_date WHERE i>'2004-10-26'::date ORDER BY i;
+     i      
+------------
+ 10-27-2004
+ 10-28-2004
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/float4.out b/contrib/btree_gin/expected/float4.out
new file mode 100644
index 0000000000..7b9134fcd4
--- /dev/null
+++ b/contrib/btree_gin/expected/float4.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_float4 (
+	i float4
+);
+INSERT INTO test_float4 VALUES (-2),(-1),(0),(1),(2),(3);
+CREATE INDEX idx_float4 ON test_float4 USING gin (i);
+SELECT * FROM test_float4 WHERE i<1::float4 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+(3 rows)
+
+SELECT * FROM test_float4 WHERE i<=1::float4 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+  1
+(4 rows)
+
+SELECT * FROM test_float4 WHERE i=1::float4 ORDER BY i;
+ i 
+---
+ 1
+(1 row)
+
+SELECT * FROM test_float4 WHERE i>=1::float4 ORDER BY i;
+ i 
+---
+ 1
+ 2
+ 3
+(3 rows)
+
+SELECT * FROM test_float4 WHERE i>1::float4 ORDER BY i;
+ i 
+---
+ 2
+ 3
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/float8.out b/contrib/btree_gin/expected/float8.out
new file mode 100644
index 0000000000..a41d4f9f6b
--- /dev/null
+++ b/contrib/btree_gin/expected/float8.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_float8 (
+	i float8
+);
+INSERT INTO test_float8 VALUES (-2),(-1),(0),(1),(2),(3);
+CREATE INDEX idx_float8 ON test_float8 USING gin (i);
+SELECT * FROM test_float8 WHERE i<1::float8 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+(3 rows)
+
+SELECT * FROM test_float8 WHERE i<=1::float8 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+  1
+(4 rows)
+
+SELECT * FROM test_float8 WHERE i=1::float8 ORDER BY i;
+ i 
+---
+ 1
+(1 row)
+
+SELECT * FROM test_float8 WHERE i>=1::float8 ORDER BY i;
+ i 
+---
+ 1
+ 2
+ 3
+(3 rows)
+
+SELECT * FROM test_float8 WHERE i>1::float8 ORDER BY i;
+ i 
+---
+ 2
+ 3
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/inet.out b/contrib/btree_gin/expected/inet.out
new file mode 100644
index 0000000000..bb2eaafc7f
--- /dev/null
+++ b/contrib/btree_gin/expected/inet.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_inet (
+	i inet
+);
+INSERT INTO test_inet VALUES 
+	( '1.2.3.4/16' ),
+	( '1.2.4.4/16' ),
+	( '1.2.5.4/16' ),
+	( '1.2.6.4/16' ),
+	( '1.2.7.4/16' ),
+	( '1.2.8.4/16' )
+;
+CREATE INDEX idx_inet ON test_inet USING gin (i);
+SELECT * FROM test_inet WHERE i<'1.2.6.4/16'::inet ORDER BY i;
+     i      
+------------
+ 1.2.3.4/16
+ 1.2.4.4/16
+ 1.2.5.4/16
+(3 rows)
+
+SELECT * FROM test_inet WHERE i<='1.2.6.4/16'::inet ORDER BY i;
+     i      
+------------
+ 1.2.3.4/16
+ 1.2.4.4/16
+ 1.2.5.4/16
+ 1.2.6.4/16
+(4 rows)
+
+SELECT * FROM test_inet WHERE i='1.2.6.4/16'::inet ORDER BY i;
+     i      
+------------
+ 1.2.6.4/16
+(1 row)
+
+SELECT * FROM test_inet WHERE i>='1.2.6.4/16'::inet ORDER BY i;
+     i      
+------------
+ 1.2.6.4/16
+ 1.2.7.4/16
+ 1.2.8.4/16
+(3 rows)
+
+SELECT * FROM test_inet WHERE i>'1.2.6.4/16'::inet ORDER BY i;
+     i      
+------------
+ 1.2.7.4/16
+ 1.2.8.4/16
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/install_btree_gin.out b/contrib/btree_gin/expected/install_btree_gin.out
new file mode 100644
index 0000000000..43f11fa263
--- /dev/null
+++ b/contrib/btree_gin/expected/install_btree_gin.out
@@ -0,0 +1,3 @@
+SET client_min_messages = warning;
+\set ECHO none
+RESET client_min_messages;
diff --git a/contrib/btree_gin/expected/int2.out b/contrib/btree_gin/expected/int2.out
new file mode 100644
index 0000000000..20d66a1b05
--- /dev/null
+++ b/contrib/btree_gin/expected/int2.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_int2 (
+	i int2
+);
+INSERT INTO test_int2 VALUES (-2),(-1),(0),(1),(2),(3);
+CREATE INDEX idx_int2 ON test_int2 USING gin (i);
+SELECT * FROM test_int2 WHERE i<1::int2 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+(3 rows)
+
+SELECT * FROM test_int2 WHERE i<=1::int2 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+  1
+(4 rows)
+
+SELECT * FROM test_int2 WHERE i=1::int2 ORDER BY i;
+ i 
+---
+ 1
+(1 row)
+
+SELECT * FROM test_int2 WHERE i>=1::int2 ORDER BY i;
+ i 
+---
+ 1
+ 2
+ 3
+(3 rows)
+
+SELECT * FROM test_int2 WHERE i>1::int2 ORDER BY i;
+ i 
+---
+ 2
+ 3
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/int4.out b/contrib/btree_gin/expected/int4.out
new file mode 100644
index 0000000000..0f0122c6f5
--- /dev/null
+++ b/contrib/btree_gin/expected/int4.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_int4 (
+	i int4
+);
+INSERT INTO test_int4 VALUES (-2),(-1),(0),(1),(2),(3);
+CREATE INDEX idx_int4 ON test_int4 USING gin (i);
+SELECT * FROM test_int4 WHERE i<1::int4 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+(3 rows)
+
+SELECT * FROM test_int4 WHERE i<=1::int4 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+  1
+(4 rows)
+
+SELECT * FROM test_int4 WHERE i=1::int4 ORDER BY i;
+ i 
+---
+ 1
+(1 row)
+
+SELECT * FROM test_int4 WHERE i>=1::int4 ORDER BY i;
+ i 
+---
+ 1
+ 2
+ 3
+(3 rows)
+
+SELECT * FROM test_int4 WHERE i>1::int4 ORDER BY i;
+ i 
+---
+ 2
+ 3
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/int8.out b/contrib/btree_gin/expected/int8.out
new file mode 100644
index 0000000000..307e19e7a0
--- /dev/null
+++ b/contrib/btree_gin/expected/int8.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_int8 (
+	i int8
+);
+INSERT INTO test_int8 VALUES (-2),(-1),(0),(1),(2),(3);
+CREATE INDEX idx_int8 ON test_int8 USING gin (i);
+SELECT * FROM test_int8 WHERE i<1::int8 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+(3 rows)
+
+SELECT * FROM test_int8 WHERE i<=1::int8 ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+  1
+(4 rows)
+
+SELECT * FROM test_int8 WHERE i=1::int8 ORDER BY i;
+ i 
+---
+ 1
+(1 row)
+
+SELECT * FROM test_int8 WHERE i>=1::int8 ORDER BY i;
+ i 
+---
+ 1
+ 2
+ 3
+(3 rows)
+
+SELECT * FROM test_int8 WHERE i>1::int8 ORDER BY i;
+ i 
+---
+ 2
+ 3
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/interval.out b/contrib/btree_gin/expected/interval.out
new file mode 100644
index 0000000000..a3b99c1f28
--- /dev/null
+++ b/contrib/btree_gin/expected/interval.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_interval (
+	i interval
+);
+INSERT INTO test_interval VALUES 
+	( '03:55:08' ),
+	( '04:55:08' ),
+	( '05:55:08' ),
+	( '08:55:08' ),
+	( '09:55:08' ),
+	( '10:55:08' )
+;
+CREATE INDEX idx_interval ON test_interval USING gin (i);
+SELECT * FROM test_interval WHERE i<'08:55:08'::interval ORDER BY i;
+            i             
+--------------------------
+ @ 3 hours 55 mins 8 secs
+ @ 4 hours 55 mins 8 secs
+ @ 5 hours 55 mins 8 secs
+(3 rows)
+
+SELECT * FROM test_interval WHERE i<='08:55:08'::interval ORDER BY i;
+            i             
+--------------------------
+ @ 3 hours 55 mins 8 secs
+ @ 4 hours 55 mins 8 secs
+ @ 5 hours 55 mins 8 secs
+ @ 8 hours 55 mins 8 secs
+(4 rows)
+
+SELECT * FROM test_interval WHERE i='08:55:08'::interval ORDER BY i;
+            i             
+--------------------------
+ @ 8 hours 55 mins 8 secs
+(1 row)
+
+SELECT * FROM test_interval WHERE i>='08:55:08'::interval ORDER BY i;
+             i             
+---------------------------
+ @ 8 hours 55 mins 8 secs
+ @ 9 hours 55 mins 8 secs
+ @ 10 hours 55 mins 8 secs
+(3 rows)
+
+SELECT * FROM test_interval WHERE i>'08:55:08'::interval ORDER BY i;
+             i             
+---------------------------
+ @ 9 hours 55 mins 8 secs
+ @ 10 hours 55 mins 8 secs
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/macaddr.out b/contrib/btree_gin/expected/macaddr.out
new file mode 100644
index 0000000000..d26d1f9ad3
--- /dev/null
+++ b/contrib/btree_gin/expected/macaddr.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_macaddr (
+	i macaddr
+);
+INSERT INTO test_macaddr VALUES 
+	( '22:00:5c:03:55:08' ),
+	( '22:00:5c:04:55:08' ),
+	( '22:00:5c:05:55:08' ),
+	( '22:00:5c:08:55:08' ),
+	( '22:00:5c:09:55:08' ),
+	( '22:00:5c:10:55:08' )
+;
+CREATE INDEX idx_macaddr ON test_macaddr USING gin (i);
+SELECT * FROM test_macaddr WHERE i<'22:00:5c:08:55:08'::macaddr ORDER BY i;
+         i         
+-------------------
+ 22:00:5c:03:55:08
+ 22:00:5c:04:55:08
+ 22:00:5c:05:55:08
+(3 rows)
+
+SELECT * FROM test_macaddr WHERE i<='22:00:5c:08:55:08'::macaddr ORDER BY i;
+         i         
+-------------------
+ 22:00:5c:03:55:08
+ 22:00:5c:04:55:08
+ 22:00:5c:05:55:08
+ 22:00:5c:08:55:08
+(4 rows)
+
+SELECT * FROM test_macaddr WHERE i='22:00:5c:08:55:08'::macaddr ORDER BY i;
+         i         
+-------------------
+ 22:00:5c:08:55:08
+(1 row)
+
+SELECT * FROM test_macaddr WHERE i>='22:00:5c:08:55:08'::macaddr ORDER BY i;
+         i         
+-------------------
+ 22:00:5c:08:55:08
+ 22:00:5c:09:55:08
+ 22:00:5c:10:55:08
+(3 rows)
+
+SELECT * FROM test_macaddr WHERE i>'22:00:5c:08:55:08'::macaddr ORDER BY i;
+         i         
+-------------------
+ 22:00:5c:09:55:08
+ 22:00:5c:10:55:08
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/money.out b/contrib/btree_gin/expected/money.out
new file mode 100644
index 0000000000..a0ba571cfd
--- /dev/null
+++ b/contrib/btree_gin/expected/money.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_money (
+	i money
+);
+INSERT INTO test_money VALUES ('-2'),('-1'),('0'),('1'),('2'),('3');
+CREATE INDEX idx_money ON test_money USING gin (i);
+SELECT * FROM test_money WHERE i<'1'::money ORDER BY i;
+   i    
+--------
+ -$2.00
+ -$1.00
+  $0.00
+(3 rows)
+
+SELECT * FROM test_money WHERE i<='1'::money ORDER BY i;
+   i    
+--------
+ -$2.00
+ -$1.00
+  $0.00
+  $1.00
+(4 rows)
+
+SELECT * FROM test_money WHERE i='1'::money ORDER BY i;
+   i   
+-------
+ $1.00
+(1 row)
+
+SELECT * FROM test_money WHERE i>='1'::money ORDER BY i;
+   i   
+-------
+ $1.00
+ $2.00
+ $3.00
+(3 rows)
+
+SELECT * FROM test_money WHERE i>'1'::money ORDER BY i;
+   i   
+-------
+ $2.00
+ $3.00
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/numeric.out b/contrib/btree_gin/expected/numeric.out
new file mode 100644
index 0000000000..f10a672c9b
--- /dev/null
+++ b/contrib/btree_gin/expected/numeric.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_numeric (
+	i numeric
+);
+INSERT INTO test_numeric VALUES (-2),(-1),(0),(1),(2),(3);
+CREATE INDEX idx_numeric ON test_numeric USING gin (i);
+SELECT * FROM test_numeric WHERE i<'1'::numeric ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+(3 rows)
+
+SELECT * FROM test_numeric WHERE i<='1'::numeric ORDER BY i;
+ i  
+----
+ -2
+ -1
+  0
+  1
+(4 rows)
+
+SELECT * FROM test_numeric WHERE i='1'::numeric ORDER BY i;
+ i 
+---
+ 1
+(1 row)
+
+SELECT * FROM test_numeric WHERE i>='1'::numeric ORDER BY i;
+ i 
+---
+ 1
+ 2
+ 3
+(3 rows)
+
+SELECT * FROM test_numeric WHERE i>'1'::numeric ORDER BY i;
+ i 
+---
+ 2
+ 3
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/oid.out b/contrib/btree_gin/expected/oid.out
new file mode 100644
index 0000000000..19e15c7f8e
--- /dev/null
+++ b/contrib/btree_gin/expected/oid.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_oid (
+	i oid
+);
+INSERT INTO test_oid VALUES (0),(1),(2),(3),(4),(5);
+CREATE INDEX idx_oid ON test_oid USING gin (i);
+SELECT * FROM test_oid WHERE i<3::oid ORDER BY i;
+ i 
+---
+ 0
+ 1
+ 2
+(3 rows)
+
+SELECT * FROM test_oid WHERE i<=3::oid ORDER BY i;
+ i 
+---
+ 0
+ 1
+ 2
+ 3
+(4 rows)
+
+SELECT * FROM test_oid WHERE i=3::oid ORDER BY i;
+ i 
+---
+ 3
+(1 row)
+
+SELECT * FROM test_oid WHERE i>=3::oid ORDER BY i;
+ i 
+---
+ 3
+ 4
+ 5
+(3 rows)
+
+SELECT * FROM test_oid WHERE i>3::oid ORDER BY i;
+ i 
+---
+ 4
+ 5
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/text.out b/contrib/btree_gin/expected/text.out
new file mode 100644
index 0000000000..1ed206eec7
--- /dev/null
+++ b/contrib/btree_gin/expected/text.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_text (
+	i text
+);
+INSERT INTO test_text VALUES ('aaa'),('a'),('abc'),('abb'),('axy'),('xyz');
+CREATE INDEX idx_text ON test_text USING gin (i);
+SELECT * FROM test_text WHERE i<'abc' ORDER BY i;
+  i  
+-----
+ a
+ aaa
+ abb
+(3 rows)
+
+SELECT * FROM test_text WHERE i<='abc' ORDER BY i;
+  i  
+-----
+ a
+ aaa
+ abb
+ abc
+(4 rows)
+
+SELECT * FROM test_text WHERE i='abc' ORDER BY i;
+  i  
+-----
+ abc
+(1 row)
+
+SELECT * FROM test_text WHERE i>='abc' ORDER BY i;
+  i  
+-----
+ abc
+ axy
+ xyz
+(3 rows)
+
+SELECT * FROM test_text WHERE i>'abc' ORDER BY i;
+  i  
+-----
+ axy
+ xyz
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/time.out b/contrib/btree_gin/expected/time.out
new file mode 100644
index 0000000000..bf65946835
--- /dev/null
+++ b/contrib/btree_gin/expected/time.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_time (
+	i time
+);
+INSERT INTO test_time VALUES 
+	( '03:55:08' ),
+	( '04:55:08' ),
+	( '05:55:08' ),
+	( '08:55:08' ),
+	( '09:55:08' ),
+	( '10:55:08' )
+;
+CREATE INDEX idx_time ON test_time USING gin (i);
+SELECT * FROM test_time WHERE i<'08:55:08'::time ORDER BY i;
+    i     
+----------
+ 03:55:08
+ 04:55:08
+ 05:55:08
+(3 rows)
+
+SELECT * FROM test_time WHERE i<='08:55:08'::time ORDER BY i;
+    i     
+----------
+ 03:55:08
+ 04:55:08
+ 05:55:08
+ 08:55:08
+(4 rows)
+
+SELECT * FROM test_time WHERE i='08:55:08'::time ORDER BY i;
+    i     
+----------
+ 08:55:08
+(1 row)
+
+SELECT * FROM test_time WHERE i>='08:55:08'::time ORDER BY i;
+    i     
+----------
+ 08:55:08
+ 09:55:08
+ 10:55:08
+(3 rows)
+
+SELECT * FROM test_time WHERE i>'08:55:08'::time ORDER BY i;
+    i     
+----------
+ 09:55:08
+ 10:55:08
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/timestamp.out b/contrib/btree_gin/expected/timestamp.out
new file mode 100644
index 0000000000..00b0b66106
--- /dev/null
+++ b/contrib/btree_gin/expected/timestamp.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_timestamp (
+	i timestamp
+);
+INSERT INTO test_timestamp VALUES 
+	( '2004-10-26 03:55:08' ),
+	( '2004-10-26 04:55:08' ),
+	( '2004-10-26 05:55:08' ),
+	( '2004-10-26 08:55:08' ),
+	( '2004-10-26 09:55:08' ),
+	( '2004-10-26 10:55:08' )
+;
+CREATE INDEX idx_timestamp ON test_timestamp USING gin (i);
+SELECT * FROM test_timestamp WHERE i<'2004-10-26 08:55:08'::timestamp ORDER BY i;
+            i             
+--------------------------
+ Tue Oct 26 03:55:08 2004
+ Tue Oct 26 04:55:08 2004
+ Tue Oct 26 05:55:08 2004
+(3 rows)
+
+SELECT * FROM test_timestamp WHERE i<='2004-10-26 08:55:08'::timestamp ORDER BY i;
+            i             
+--------------------------
+ Tue Oct 26 03:55:08 2004
+ Tue Oct 26 04:55:08 2004
+ Tue Oct 26 05:55:08 2004
+ Tue Oct 26 08:55:08 2004
+(4 rows)
+
+SELECT * FROM test_timestamp WHERE i='2004-10-26 08:55:08'::timestamp ORDER BY i;
+            i             
+--------------------------
+ Tue Oct 26 08:55:08 2004
+(1 row)
+
+SELECT * FROM test_timestamp WHERE i>='2004-10-26 08:55:08'::timestamp ORDER BY i;
+            i             
+--------------------------
+ Tue Oct 26 08:55:08 2004
+ Tue Oct 26 09:55:08 2004
+ Tue Oct 26 10:55:08 2004
+(3 rows)
+
+SELECT * FROM test_timestamp WHERE i>'2004-10-26 08:55:08'::timestamp ORDER BY i;
+            i             
+--------------------------
+ Tue Oct 26 09:55:08 2004
+ Tue Oct 26 10:55:08 2004
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/timestamptz.out b/contrib/btree_gin/expected/timestamptz.out
new file mode 100644
index 0000000000..8550d6b4d9
--- /dev/null
+++ b/contrib/btree_gin/expected/timestamptz.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_timestamptz (
+	i timestamptz
+);
+INSERT INTO test_timestamptz VALUES 
+	( '2004-10-26 03:55:08' ),
+	( '2004-10-26 04:55:08' ),
+	( '2004-10-26 05:55:08' ),
+	( '2004-10-26 08:55:08' ),
+	( '2004-10-26 09:55:08' ),
+	( '2004-10-26 10:55:08' )
+;
+CREATE INDEX idx_timestamptz ON test_timestamptz USING gin (i);
+SELECT * FROM test_timestamptz WHERE i<'2004-10-26 08:55:08'::timestamptz ORDER BY i;
+              i               
+------------------------------
+ Tue Oct 26 03:55:08 2004 PDT
+ Tue Oct 26 04:55:08 2004 PDT
+ Tue Oct 26 05:55:08 2004 PDT
+(3 rows)
+
+SELECT * FROM test_timestamptz WHERE i<='2004-10-26 08:55:08'::timestamptz ORDER BY i;
+              i               
+------------------------------
+ Tue Oct 26 03:55:08 2004 PDT
+ Tue Oct 26 04:55:08 2004 PDT
+ Tue Oct 26 05:55:08 2004 PDT
+ Tue Oct 26 08:55:08 2004 PDT
+(4 rows)
+
+SELECT * FROM test_timestamptz WHERE i='2004-10-26 08:55:08'::timestamptz ORDER BY i;
+              i               
+------------------------------
+ Tue Oct 26 08:55:08 2004 PDT
+(1 row)
+
+SELECT * FROM test_timestamptz WHERE i>='2004-10-26 08:55:08'::timestamptz ORDER BY i;
+              i               
+------------------------------
+ Tue Oct 26 08:55:08 2004 PDT
+ Tue Oct 26 09:55:08 2004 PDT
+ Tue Oct 26 10:55:08 2004 PDT
+(3 rows)
+
+SELECT * FROM test_timestamptz WHERE i>'2004-10-26 08:55:08'::timestamptz ORDER BY i;
+              i               
+------------------------------
+ Tue Oct 26 09:55:08 2004 PDT
+ Tue Oct 26 10:55:08 2004 PDT
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/timetz.out b/contrib/btree_gin/expected/timetz.out
new file mode 100644
index 0000000000..184bc310f6
--- /dev/null
+++ b/contrib/btree_gin/expected/timetz.out
@@ -0,0 +1,51 @@
+set enable_seqscan=off;
+CREATE TABLE test_timetz (
+	i timetz
+);
+INSERT INTO test_timetz VALUES 
+	( '03:55:08 GMT+2' ),
+	( '04:55:08 GMT+2' ),
+	( '05:55:08 GMT+2' ),
+	( '08:55:08 GMT+2' ),
+	( '09:55:08 GMT+2' ),
+	( '10:55:08 GMT+2' )
+;
+CREATE INDEX idx_timetz ON test_timetz USING gin (i);
+SELECT * FROM test_timetz WHERE i<'08:55:08 GMT+2'::timetz ORDER BY i;
+      i      
+-------------
+ 03:55:08-02
+ 04:55:08-02
+ 05:55:08-02
+(3 rows)
+
+SELECT * FROM test_timetz WHERE i<='08:55:08 GMT+2'::timetz ORDER BY i;
+      i      
+-------------
+ 03:55:08-02
+ 04:55:08-02
+ 05:55:08-02
+ 08:55:08-02
+(4 rows)
+
+SELECT * FROM test_timetz WHERE i='08:55:08 GMT+2'::timetz ORDER BY i;
+      i      
+-------------
+ 08:55:08-02
+(1 row)
+
+SELECT * FROM test_timetz WHERE i>='08:55:08 GMT+2'::timetz ORDER BY i;
+      i      
+-------------
+ 08:55:08-02
+ 09:55:08-02
+ 10:55:08-02
+(3 rows)
+
+SELECT * FROM test_timetz WHERE i>'08:55:08 GMT+2'::timetz ORDER BY i;
+      i      
+-------------
+ 09:55:08-02
+ 10:55:08-02
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/varbit.out b/contrib/btree_gin/expected/varbit.out
new file mode 100644
index 0000000000..e8a77180c3
--- /dev/null
+++ b/contrib/btree_gin/expected/varbit.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_varbit (
+	i varbit
+);
+INSERT INTO test_varbit VALUES ('001'),('010'),('011'),('100'),('101'),('110');
+CREATE INDEX idx_varbit ON test_varbit USING gin (i);
+SELECT * FROM test_varbit WHERE i<'100'::varbit ORDER BY i;
+  i  
+-----
+ 001
+ 010
+ 011
+(3 rows)
+
+SELECT * FROM test_varbit WHERE i<='100'::varbit ORDER BY i;
+  i  
+-----
+ 001
+ 010
+ 011
+ 100
+(4 rows)
+
+SELECT * FROM test_varbit WHERE i='100'::varbit ORDER BY i;
+  i  
+-----
+ 100
+(1 row)
+
+SELECT * FROM test_varbit WHERE i>='100'::varbit ORDER BY i;
+  i  
+-----
+ 100
+ 101
+ 110
+(3 rows)
+
+SELECT * FROM test_varbit WHERE i>'100'::varbit ORDER BY i;
+  i  
+-----
+ 101
+ 110
+(2 rows)
+
diff --git a/contrib/btree_gin/expected/varchar.out b/contrib/btree_gin/expected/varchar.out
new file mode 100644
index 0000000000..b893dd976d
--- /dev/null
+++ b/contrib/btree_gin/expected/varchar.out
@@ -0,0 +1,44 @@
+set enable_seqscan=off;
+CREATE TABLE test_varchar (
+	i varchar
+);
+INSERT INTO test_varchar VALUES ('aaa'),('a'),('abc'),('abb'),('axy'),('xyz');
+CREATE INDEX idx_varchar ON test_varchar USING gin (i);
+SELECT * FROM test_varchar WHERE i<'abc'::varchar ORDER BY i;
+  i  
+-----
+ a
+ aaa
+ abb
+(3 rows)
+
+SELECT * FROM test_varchar WHERE i<='abc'::varchar ORDER BY i;
+  i  
+-----
+ a
+ aaa
+ abb
+ abc
+(4 rows)
+
+SELECT * FROM test_varchar WHERE i='abc'::varchar ORDER BY i;
+  i  
+-----
+ abc
+(1 row)
+
+SELECT * FROM test_varchar WHERE i>='abc'::varchar ORDER BY i;
+  i  
+-----
+ abc
+ axy
+ xyz
+(3 rows)
+
+SELECT * FROM test_varchar WHERE i>'abc'::varchar ORDER BY i;
+  i  
+-----
+ axy
+ xyz
+(2 rows)
+
diff --git a/contrib/btree_gin/sql/bit.sql b/contrib/btree_gin/sql/bit.sql
new file mode 100644
index 0000000000..6762be0ef2
--- /dev/null
+++ b/contrib/btree_gin/sql/bit.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_bit (
+	i bit(3)
+);
+
+INSERT INTO test_bit VALUES ('001'),('010'),('011'),('100'),('101'),('110');
+
+CREATE INDEX idx_bit ON test_bit USING gin (i);
+
+SELECT * FROM test_bit WHERE i<'100'::bit(3) ORDER BY i;
+SELECT * FROM test_bit WHERE i<='100'::bit(3) ORDER BY i;
+SELECT * FROM test_bit WHERE i='100'::bit(3) ORDER BY i;
+SELECT * FROM test_bit WHERE i>='100'::bit(3) ORDER BY i;
+SELECT * FROM test_bit WHERE i>'100'::bit(3) ORDER BY i;
diff --git a/contrib/btree_gin/sql/bytea.sql b/contrib/btree_gin/sql/bytea.sql
new file mode 100644
index 0000000000..96be56bf65
--- /dev/null
+++ b/contrib/btree_gin/sql/bytea.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_bytea (
+	i bytea
+);
+
+INSERT INTO test_bytea VALUES ('aaa'),('a'),('abc'),('abb'),('axy'),('xyz');
+
+CREATE INDEX idx_bytea ON test_bytea USING gin (i);
+
+SELECT * FROM test_bytea WHERE i<'abc'::bytea ORDER BY i;
+SELECT * FROM test_bytea WHERE i<='abc'::bytea ORDER BY i;
+SELECT * FROM test_bytea WHERE i='abc'::bytea ORDER BY i;
+SELECT * FROM test_bytea WHERE i>='abc'::bytea ORDER BY i;
+SELECT * FROM test_bytea WHERE i>'abc'::bytea ORDER BY i;
diff --git a/contrib/btree_gin/sql/char.sql b/contrib/btree_gin/sql/char.sql
new file mode 100644
index 0000000000..1f114a5eb1
--- /dev/null
+++ b/contrib/btree_gin/sql/char.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_char (
+	i "char"
+);
+
+INSERT INTO test_char VALUES ('a'),('b'),('c'),('d'),('e'),('f');
+
+CREATE INDEX idx_char ON test_char USING gin (i);
+
+SELECT * FROM test_char WHERE i<'d'::"char" ORDER BY i;
+SELECT * FROM test_char WHERE i<='d'::"char" ORDER BY i;
+SELECT * FROM test_char WHERE i='d'::"char" ORDER BY i;
+SELECT * FROM test_char WHERE i>='d'::"char" ORDER BY i;
+SELECT * FROM test_char WHERE i>'d'::"char" ORDER BY i;
diff --git a/contrib/btree_gin/sql/cidr.sql b/contrib/btree_gin/sql/cidr.sql
new file mode 100644
index 0000000000..a608a3ec78
--- /dev/null
+++ b/contrib/btree_gin/sql/cidr.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_cidr (
+	i cidr
+);
+
+INSERT INTO test_cidr VALUES 
+	( '1.2.3.4' ),
+	( '1.2.4.4' ),
+	( '1.2.5.4' ),
+	( '1.2.6.4' ),
+	( '1.2.7.4' ),
+	( '1.2.8.4' )
+;
+
+CREATE INDEX idx_cidr ON test_cidr USING gin (i);
+
+SELECT * FROM test_cidr WHERE i<'1.2.6.4'::cidr ORDER BY i;
+SELECT * FROM test_cidr WHERE i<='1.2.6.4'::cidr ORDER BY i;
+SELECT * FROM test_cidr WHERE i='1.2.6.4'::cidr ORDER BY i;
+SELECT * FROM test_cidr WHERE i>='1.2.6.4'::cidr ORDER BY i;
+SELECT * FROM test_cidr WHERE i>'1.2.6.4'::cidr ORDER BY i;
diff --git a/contrib/btree_gin/sql/date.sql b/contrib/btree_gin/sql/date.sql
new file mode 100644
index 0000000000..c486f272a4
--- /dev/null
+++ b/contrib/btree_gin/sql/date.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_date (
+	i date
+);
+
+INSERT INTO test_date VALUES 
+	( '2004-10-23' ),
+	( '2004-10-24' ),
+	( '2004-10-25' ),
+	( '2004-10-26' ),
+	( '2004-10-27' ),
+	( '2004-10-28' )
+;
+
+CREATE INDEX idx_date ON test_date USING gin (i);
+
+SELECT * FROM test_date WHERE i<'2004-10-26'::date ORDER BY i;
+SELECT * FROM test_date WHERE i<='2004-10-26'::date ORDER BY i;
+SELECT * FROM test_date WHERE i='2004-10-26'::date ORDER BY i;
+SELECT * FROM test_date WHERE i>='2004-10-26'::date ORDER BY i;
+SELECT * FROM test_date WHERE i>'2004-10-26'::date ORDER BY i;
diff --git a/contrib/btree_gin/sql/float4.sql b/contrib/btree_gin/sql/float4.sql
new file mode 100644
index 0000000000..759778ad3c
--- /dev/null
+++ b/contrib/btree_gin/sql/float4.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_float4 (
+	i float4
+);
+
+INSERT INTO test_float4 VALUES (-2),(-1),(0),(1),(2),(3);
+
+CREATE INDEX idx_float4 ON test_float4 USING gin (i);
+
+SELECT * FROM test_float4 WHERE i<1::float4 ORDER BY i;
+SELECT * FROM test_float4 WHERE i<=1::float4 ORDER BY i;
+SELECT * FROM test_float4 WHERE i=1::float4 ORDER BY i;
+SELECT * FROM test_float4 WHERE i>=1::float4 ORDER BY i;
+SELECT * FROM test_float4 WHERE i>1::float4 ORDER BY i;
diff --git a/contrib/btree_gin/sql/float8.sql b/contrib/btree_gin/sql/float8.sql
new file mode 100644
index 0000000000..b046ac4e6c
--- /dev/null
+++ b/contrib/btree_gin/sql/float8.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_float8 (
+	i float8
+);
+
+INSERT INTO test_float8 VALUES (-2),(-1),(0),(1),(2),(3);
+
+CREATE INDEX idx_float8 ON test_float8 USING gin (i);
+
+SELECT * FROM test_float8 WHERE i<1::float8 ORDER BY i;
+SELECT * FROM test_float8 WHERE i<=1::float8 ORDER BY i;
+SELECT * FROM test_float8 WHERE i=1::float8 ORDER BY i;
+SELECT * FROM test_float8 WHERE i>=1::float8 ORDER BY i;
+SELECT * FROM test_float8 WHERE i>1::float8 ORDER BY i;
diff --git a/contrib/btree_gin/sql/inet.sql b/contrib/btree_gin/sql/inet.sql
new file mode 100644
index 0000000000..fadc1c47ec
--- /dev/null
+++ b/contrib/btree_gin/sql/inet.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_inet (
+	i inet
+);
+
+INSERT INTO test_inet VALUES 
+	( '1.2.3.4/16' ),
+	( '1.2.4.4/16' ),
+	( '1.2.5.4/16' ),
+	( '1.2.6.4/16' ),
+	( '1.2.7.4/16' ),
+	( '1.2.8.4/16' )
+;
+
+CREATE INDEX idx_inet ON test_inet USING gin (i);
+
+SELECT * FROM test_inet WHERE i<'1.2.6.4/16'::inet ORDER BY i;
+SELECT * FROM test_inet WHERE i<='1.2.6.4/16'::inet ORDER BY i;
+SELECT * FROM test_inet WHERE i='1.2.6.4/16'::inet ORDER BY i;
+SELECT * FROM test_inet WHERE i>='1.2.6.4/16'::inet ORDER BY i;
+SELECT * FROM test_inet WHERE i>'1.2.6.4/16'::inet ORDER BY i;
diff --git a/contrib/btree_gin/sql/install_btree_gin.sql b/contrib/btree_gin/sql/install_btree_gin.sql
new file mode 100644
index 0000000000..f54c8b4a0f
--- /dev/null
+++ b/contrib/btree_gin/sql/install_btree_gin.sql
@@ -0,0 +1,5 @@
+SET client_min_messages = warning;
+\set ECHO none
+\i btree_gin.sql
+\set ECHO all
+RESET client_min_messages;
diff --git a/contrib/btree_gin/sql/int2.sql b/contrib/btree_gin/sql/int2.sql
new file mode 100644
index 0000000000..f06f11702f
--- /dev/null
+++ b/contrib/btree_gin/sql/int2.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_int2 (
+	i int2
+);
+
+INSERT INTO test_int2 VALUES (-2),(-1),(0),(1),(2),(3);
+
+CREATE INDEX idx_int2 ON test_int2 USING gin (i);
+
+SELECT * FROM test_int2 WHERE i<1::int2 ORDER BY i;
+SELECT * FROM test_int2 WHERE i<=1::int2 ORDER BY i;
+SELECT * FROM test_int2 WHERE i=1::int2 ORDER BY i;
+SELECT * FROM test_int2 WHERE i>=1::int2 ORDER BY i;
+SELECT * FROM test_int2 WHERE i>1::int2 ORDER BY i;
diff --git a/contrib/btree_gin/sql/int4.sql b/contrib/btree_gin/sql/int4.sql
new file mode 100644
index 0000000000..6499c29630
--- /dev/null
+++ b/contrib/btree_gin/sql/int4.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_int4 (
+	i int4
+);
+
+INSERT INTO test_int4 VALUES (-2),(-1),(0),(1),(2),(3);
+
+CREATE INDEX idx_int4 ON test_int4 USING gin (i);
+
+SELECT * FROM test_int4 WHERE i<1::int4 ORDER BY i;
+SELECT * FROM test_int4 WHERE i<=1::int4 ORDER BY i;
+SELECT * FROM test_int4 WHERE i=1::int4 ORDER BY i;
+SELECT * FROM test_int4 WHERE i>=1::int4 ORDER BY i;
+SELECT * FROM test_int4 WHERE i>1::int4 ORDER BY i;
diff --git a/contrib/btree_gin/sql/int8.sql b/contrib/btree_gin/sql/int8.sql
new file mode 100644
index 0000000000..4d9c287181
--- /dev/null
+++ b/contrib/btree_gin/sql/int8.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_int8 (
+	i int8
+);
+
+INSERT INTO test_int8 VALUES (-2),(-1),(0),(1),(2),(3);
+
+CREATE INDEX idx_int8 ON test_int8 USING gin (i);
+
+SELECT * FROM test_int8 WHERE i<1::int8 ORDER BY i;
+SELECT * FROM test_int8 WHERE i<=1::int8 ORDER BY i;
+SELECT * FROM test_int8 WHERE i=1::int8 ORDER BY i;
+SELECT * FROM test_int8 WHERE i>=1::int8 ORDER BY i;
+SELECT * FROM test_int8 WHERE i>1::int8 ORDER BY i;
diff --git a/contrib/btree_gin/sql/interval.sql b/contrib/btree_gin/sql/interval.sql
new file mode 100644
index 0000000000..f245e4d4b3
--- /dev/null
+++ b/contrib/btree_gin/sql/interval.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_interval (
+	i interval
+);
+
+INSERT INTO test_interval VALUES 
+	( '03:55:08' ),
+	( '04:55:08' ),
+	( '05:55:08' ),
+	( '08:55:08' ),
+	( '09:55:08' ),
+	( '10:55:08' )
+;
+
+CREATE INDEX idx_interval ON test_interval USING gin (i);
+
+SELECT * FROM test_interval WHERE i<'08:55:08'::interval ORDER BY i;
+SELECT * FROM test_interval WHERE i<='08:55:08'::interval ORDER BY i;
+SELECT * FROM test_interval WHERE i='08:55:08'::interval ORDER BY i;
+SELECT * FROM test_interval WHERE i>='08:55:08'::interval ORDER BY i;
+SELECT * FROM test_interval WHERE i>'08:55:08'::interval ORDER BY i;
diff --git a/contrib/btree_gin/sql/macaddr.sql b/contrib/btree_gin/sql/macaddr.sql
new file mode 100644
index 0000000000..e0402869a8
--- /dev/null
+++ b/contrib/btree_gin/sql/macaddr.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_macaddr (
+	i macaddr
+);
+
+INSERT INTO test_macaddr VALUES 
+	( '22:00:5c:03:55:08' ),
+	( '22:00:5c:04:55:08' ),
+	( '22:00:5c:05:55:08' ),
+	( '22:00:5c:08:55:08' ),
+	( '22:00:5c:09:55:08' ),
+	( '22:00:5c:10:55:08' )
+;
+
+CREATE INDEX idx_macaddr ON test_macaddr USING gin (i);
+
+SELECT * FROM test_macaddr WHERE i<'22:00:5c:08:55:08'::macaddr ORDER BY i;
+SELECT * FROM test_macaddr WHERE i<='22:00:5c:08:55:08'::macaddr ORDER BY i;
+SELECT * FROM test_macaddr WHERE i='22:00:5c:08:55:08'::macaddr ORDER BY i;
+SELECT * FROM test_macaddr WHERE i>='22:00:5c:08:55:08'::macaddr ORDER BY i;
+SELECT * FROM test_macaddr WHERE i>'22:00:5c:08:55:08'::macaddr ORDER BY i;
diff --git a/contrib/btree_gin/sql/money.sql b/contrib/btree_gin/sql/money.sql
new file mode 100644
index 0000000000..4a9c8c5966
--- /dev/null
+++ b/contrib/btree_gin/sql/money.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_money (
+	i money
+);
+
+INSERT INTO test_money VALUES ('-2'),('-1'),('0'),('1'),('2'),('3');
+
+CREATE INDEX idx_money ON test_money USING gin (i);
+
+SELECT * FROM test_money WHERE i<'1'::money ORDER BY i;
+SELECT * FROM test_money WHERE i<='1'::money ORDER BY i;
+SELECT * FROM test_money WHERE i='1'::money ORDER BY i;
+SELECT * FROM test_money WHERE i>='1'::money ORDER BY i;
+SELECT * FROM test_money WHERE i>'1'::money ORDER BY i;
diff --git a/contrib/btree_gin/sql/numeric.sql b/contrib/btree_gin/sql/numeric.sql
new file mode 100644
index 0000000000..dbaaa2c2ef
--- /dev/null
+++ b/contrib/btree_gin/sql/numeric.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_numeric (
+	i numeric
+);
+
+INSERT INTO test_numeric VALUES (-2),(-1),(0),(1),(2),(3);
+
+CREATE INDEX idx_numeric ON test_numeric USING gin (i);
+
+SELECT * FROM test_numeric WHERE i<'1'::numeric ORDER BY i;
+SELECT * FROM test_numeric WHERE i<='1'::numeric ORDER BY i;
+SELECT * FROM test_numeric WHERE i='1'::numeric ORDER BY i;
+SELECT * FROM test_numeric WHERE i>='1'::numeric ORDER BY i;
+SELECT * FROM test_numeric WHERE i>'1'::numeric ORDER BY i;
diff --git a/contrib/btree_gin/sql/oid.sql b/contrib/btree_gin/sql/oid.sql
new file mode 100644
index 0000000000..1739f80277
--- /dev/null
+++ b/contrib/btree_gin/sql/oid.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_oid (
+	i oid
+);
+
+INSERT INTO test_oid VALUES (0),(1),(2),(3),(4),(5);
+
+CREATE INDEX idx_oid ON test_oid USING gin (i);
+
+SELECT * FROM test_oid WHERE i<3::oid ORDER BY i;
+SELECT * FROM test_oid WHERE i<=3::oid ORDER BY i;
+SELECT * FROM test_oid WHERE i=3::oid ORDER BY i;
+SELECT * FROM test_oid WHERE i>=3::oid ORDER BY i;
+SELECT * FROM test_oid WHERE i>3::oid ORDER BY i;
diff --git a/contrib/btree_gin/sql/text.sql b/contrib/btree_gin/sql/text.sql
new file mode 100644
index 0000000000..5288206af3
--- /dev/null
+++ b/contrib/btree_gin/sql/text.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_text (
+	i text
+);
+
+INSERT INTO test_text VALUES ('aaa'),('a'),('abc'),('abb'),('axy'),('xyz');
+
+CREATE INDEX idx_text ON test_text USING gin (i);
+
+SELECT * FROM test_text WHERE i<'abc' ORDER BY i;
+SELECT * FROM test_text WHERE i<='abc' ORDER BY i;
+SELECT * FROM test_text WHERE i='abc' ORDER BY i;
+SELECT * FROM test_text WHERE i>='abc' ORDER BY i;
+SELECT * FROM test_text WHERE i>'abc' ORDER BY i;
diff --git a/contrib/btree_gin/sql/time.sql b/contrib/btree_gin/sql/time.sql
new file mode 100644
index 0000000000..afb1e16ebf
--- /dev/null
+++ b/contrib/btree_gin/sql/time.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_time (
+	i time
+);
+
+INSERT INTO test_time VALUES 
+	( '03:55:08' ),
+	( '04:55:08' ),
+	( '05:55:08' ),
+	( '08:55:08' ),
+	( '09:55:08' ),
+	( '10:55:08' )
+;
+
+CREATE INDEX idx_time ON test_time USING gin (i);
+
+SELECT * FROM test_time WHERE i<'08:55:08'::time ORDER BY i;
+SELECT * FROM test_time WHERE i<='08:55:08'::time ORDER BY i;
+SELECT * FROM test_time WHERE i='08:55:08'::time ORDER BY i;
+SELECT * FROM test_time WHERE i>='08:55:08'::time ORDER BY i;
+SELECT * FROM test_time WHERE i>'08:55:08'::time ORDER BY i;
diff --git a/contrib/btree_gin/sql/timestamp.sql b/contrib/btree_gin/sql/timestamp.sql
new file mode 100644
index 0000000000..6e00cd7e40
--- /dev/null
+++ b/contrib/btree_gin/sql/timestamp.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_timestamp (
+	i timestamp
+);
+
+INSERT INTO test_timestamp VALUES 
+	( '2004-10-26 03:55:08' ),
+	( '2004-10-26 04:55:08' ),
+	( '2004-10-26 05:55:08' ),
+	( '2004-10-26 08:55:08' ),
+	( '2004-10-26 09:55:08' ),
+	( '2004-10-26 10:55:08' )
+;
+
+CREATE INDEX idx_timestamp ON test_timestamp USING gin (i);
+
+SELECT * FROM test_timestamp WHERE i<'2004-10-26 08:55:08'::timestamp ORDER BY i;
+SELECT * FROM test_timestamp WHERE i<='2004-10-26 08:55:08'::timestamp ORDER BY i;
+SELECT * FROM test_timestamp WHERE i='2004-10-26 08:55:08'::timestamp ORDER BY i;
+SELECT * FROM test_timestamp WHERE i>='2004-10-26 08:55:08'::timestamp ORDER BY i;
+SELECT * FROM test_timestamp WHERE i>'2004-10-26 08:55:08'::timestamp ORDER BY i;
diff --git a/contrib/btree_gin/sql/timestamptz.sql b/contrib/btree_gin/sql/timestamptz.sql
new file mode 100644
index 0000000000..26c01ef804
--- /dev/null
+++ b/contrib/btree_gin/sql/timestamptz.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_timestamptz (
+	i timestamptz
+);
+
+INSERT INTO test_timestamptz VALUES 
+	( '2004-10-26 03:55:08' ),
+	( '2004-10-26 04:55:08' ),
+	( '2004-10-26 05:55:08' ),
+	( '2004-10-26 08:55:08' ),
+	( '2004-10-26 09:55:08' ),
+	( '2004-10-26 10:55:08' )
+;
+
+CREATE INDEX idx_timestamptz ON test_timestamptz USING gin (i);
+
+SELECT * FROM test_timestamptz WHERE i<'2004-10-26 08:55:08'::timestamptz ORDER BY i;
+SELECT * FROM test_timestamptz WHERE i<='2004-10-26 08:55:08'::timestamptz ORDER BY i;
+SELECT * FROM test_timestamptz WHERE i='2004-10-26 08:55:08'::timestamptz ORDER BY i;
+SELECT * FROM test_timestamptz WHERE i>='2004-10-26 08:55:08'::timestamptz ORDER BY i;
+SELECT * FROM test_timestamptz WHERE i>'2004-10-26 08:55:08'::timestamptz ORDER BY i;
diff --git a/contrib/btree_gin/sql/timetz.sql b/contrib/btree_gin/sql/timetz.sql
new file mode 100644
index 0000000000..a72b105fc1
--- /dev/null
+++ b/contrib/btree_gin/sql/timetz.sql
@@ -0,0 +1,22 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_timetz (
+	i timetz
+);
+
+INSERT INTO test_timetz VALUES 
+	( '03:55:08 GMT+2' ),
+	( '04:55:08 GMT+2' ),
+	( '05:55:08 GMT+2' ),
+	( '08:55:08 GMT+2' ),
+	( '09:55:08 GMT+2' ),
+	( '10:55:08 GMT+2' )
+;
+
+CREATE INDEX idx_timetz ON test_timetz USING gin (i);
+
+SELECT * FROM test_timetz WHERE i<'08:55:08 GMT+2'::timetz ORDER BY i;
+SELECT * FROM test_timetz WHERE i<='08:55:08 GMT+2'::timetz ORDER BY i;
+SELECT * FROM test_timetz WHERE i='08:55:08 GMT+2'::timetz ORDER BY i;
+SELECT * FROM test_timetz WHERE i>='08:55:08 GMT+2'::timetz ORDER BY i;
+SELECT * FROM test_timetz WHERE i>'08:55:08 GMT+2'::timetz ORDER BY i;
diff --git a/contrib/btree_gin/sql/varbit.sql b/contrib/btree_gin/sql/varbit.sql
new file mode 100644
index 0000000000..4ad2d0c191
--- /dev/null
+++ b/contrib/btree_gin/sql/varbit.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_varbit (
+	i varbit
+);
+
+INSERT INTO test_varbit VALUES ('001'),('010'),('011'),('100'),('101'),('110');
+
+CREATE INDEX idx_varbit ON test_varbit USING gin (i);
+
+SELECT * FROM test_varbit WHERE i<'100'::varbit ORDER BY i;
+SELECT * FROM test_varbit WHERE i<='100'::varbit ORDER BY i;
+SELECT * FROM test_varbit WHERE i='100'::varbit ORDER BY i;
+SELECT * FROM test_varbit WHERE i>='100'::varbit ORDER BY i;
+SELECT * FROM test_varbit WHERE i>'100'::varbit ORDER BY i;
diff --git a/contrib/btree_gin/sql/varchar.sql b/contrib/btree_gin/sql/varchar.sql
new file mode 100644
index 0000000000..16255df426
--- /dev/null
+++ b/contrib/btree_gin/sql/varchar.sql
@@ -0,0 +1,15 @@
+set enable_seqscan=off;
+
+CREATE TABLE test_varchar (
+	i varchar
+);
+
+INSERT INTO test_varchar VALUES ('aaa'),('a'),('abc'),('abb'),('axy'),('xyz');
+
+CREATE INDEX idx_varchar ON test_varchar USING gin (i);
+
+SELECT * FROM test_varchar WHERE i<'abc'::varchar ORDER BY i;
+SELECT * FROM test_varchar WHERE i<='abc'::varchar ORDER BY i;
+SELECT * FROM test_varchar WHERE i='abc'::varchar ORDER BY i;
+SELECT * FROM test_varchar WHERE i>='abc'::varchar ORDER BY i;
+SELECT * FROM test_varchar WHERE i>'abc'::varchar ORDER BY i;
diff --git a/contrib/btree_gin/uninstall_btree_gin.sql b/contrib/btree_gin/uninstall_btree_gin.sql
new file mode 100644
index 0000000000..0b79c6037b
--- /dev/null
+++ b/contrib/btree_gin/uninstall_btree_gin.sql
@@ -0,0 +1,98 @@
+/* $PostgreSQL: pgsql/contrib/btree_gin/uninstall_btree_gin.sql,v 1.1 2009/03/25 23:20:01 tgl Exp $ */
+
+-- Adjust this setting to control where the objects get dropped.
+SET search_path = public;
+
+DROP OPERATOR FAMILY int2_ops USING gin CASCADE;
+DROP OPERATOR FAMILY int4_ops USING gin CASCADE;
+DROP OPERATOR FAMILY int8_ops USING gin CASCADE;
+DROP OPERATOR FAMILY float4_ops USING gin CASCADE;
+DROP OPERATOR FAMILY float8_ops USING gin CASCADE;
+DROP OPERATOR FAMILY money_ops USING gin CASCADE;
+DROP OPERATOR FAMILY oid_ops USING gin CASCADE;
+DROP OPERATOR FAMILY timestamp_ops USING gin CASCADE;
+DROP OPERATOR FAMILY timestamptz_ops USING gin CASCADE;
+DROP OPERATOR FAMILY time_ops USING gin CASCADE;
+DROP OPERATOR FAMILY timetz_ops USING gin CASCADE;
+DROP OPERATOR FAMILY date_ops USING gin CASCADE;
+DROP OPERATOR FAMILY interval_ops USING gin CASCADE;
+DROP OPERATOR FAMILY macaddr_ops USING gin CASCADE;
+DROP OPERATOR FAMILY inet_ops USING gin CASCADE;
+DROP OPERATOR FAMILY cidr_ops USING gin CASCADE;
+DROP OPERATOR FAMILY text_ops USING gin CASCADE;
+DROP OPERATOR FAMILY varchar_ops USING gin CASCADE;
+DROP OPERATOR FAMILY char_ops USING gin CASCADE;
+DROP OPERATOR FAMILY bytea_ops USING gin CASCADE;
+DROP OPERATOR FAMILY bit_ops USING gin CASCADE;
+DROP OPERATOR FAMILY varbit_ops USING gin CASCADE;
+DROP OPERATOR FAMILY numeric_ops USING gin CASCADE;
+
+DROP FUNCTION gin_btree_consistent(internal, int2, anyelement, int4, internal, internal);
+
+DROP FUNCTION gin_extract_value_int2(int2, internal);
+DROP FUNCTION gin_compare_prefix_int2(int2, int2, int2, internal);
+DROP FUNCTION gin_extract_query_int2(int2, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_int4(int4, internal);
+DROP FUNCTION gin_compare_prefix_int4(int4, int4, int2, internal);
+DROP FUNCTION gin_extract_query_int4(int4, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_int8(int8, internal);
+DROP FUNCTION gin_compare_prefix_int8(int8, int8, int2, internal);
+DROP FUNCTION gin_extract_query_int8(int8, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_float4(float4, internal);
+DROP FUNCTION gin_compare_prefix_float4(float4, float4, int2, internal);
+DROP FUNCTION gin_extract_query_float4(float4, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_float8(float8, internal);
+DROP FUNCTION gin_compare_prefix_float8(float8, float8, int2, internal);
+DROP FUNCTION gin_extract_query_float8(float8, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_money(money, internal);
+DROP FUNCTION gin_compare_prefix_money(money, money, int2, internal);
+DROP FUNCTION gin_extract_query_money(money, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_oid(oid, internal);
+DROP FUNCTION gin_compare_prefix_oid(oid, oid, int2, internal);
+DROP FUNCTION gin_extract_query_oid(oid, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_timestamp(timestamp, internal);
+DROP FUNCTION gin_compare_prefix_timestamp(timestamp, timestamp, int2, internal);
+DROP FUNCTION gin_extract_query_timestamp(timestamp, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_timestamptz(timestamptz, internal);
+DROP FUNCTION gin_compare_prefix_timestamptz(timestamptz, timestamptz, int2, internal);
+DROP FUNCTION gin_extract_query_timestamptz(timestamptz, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_time(time, internal);
+DROP FUNCTION gin_compare_prefix_time(time, time, int2, internal);
+DROP FUNCTION gin_extract_query_time(time, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_timetz(timetz, internal);
+DROP FUNCTION gin_compare_prefix_timetz(timetz, timetz, int2, internal);
+DROP FUNCTION gin_extract_query_timetz(timetz, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_date(date, internal);
+DROP FUNCTION gin_compare_prefix_date(date, date, int2, internal);
+DROP FUNCTION gin_extract_query_date(date, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_interval(interval, internal);
+DROP FUNCTION gin_compare_prefix_interval(interval, interval, int2, internal);
+DROP FUNCTION gin_extract_query_interval(interval, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_macaddr(macaddr, internal);
+DROP FUNCTION gin_compare_prefix_macaddr(macaddr, macaddr, int2, internal);
+DROP FUNCTION gin_extract_query_macaddr(macaddr, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_inet(inet, internal);
+DROP FUNCTION gin_compare_prefix_inet(inet, inet, int2, internal);
+DROP FUNCTION gin_extract_query_inet(inet, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_cidr(cidr, internal);
+DROP FUNCTION gin_compare_prefix_cidr(cidr, cidr, int2, internal);
+DROP FUNCTION gin_extract_query_cidr(cidr, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_text(text, internal);
+DROP FUNCTION gin_compare_prefix_text(text, text, int2, internal);
+DROP FUNCTION gin_extract_query_text(text, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_char("char", internal);
+DROP FUNCTION gin_compare_prefix_char("char", "char", int2, internal);
+DROP FUNCTION gin_extract_query_char("char", internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_bytea(bytea, internal);
+DROP FUNCTION gin_compare_prefix_bytea(bytea, bytea, int2, internal);
+DROP FUNCTION gin_extract_query_bytea(bytea, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_bit(bit, internal);
+DROP FUNCTION gin_compare_prefix_bit(bit, bit, int2, internal);
+DROP FUNCTION gin_extract_query_bit(bit, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_varbit(varbit, internal);
+DROP FUNCTION gin_compare_prefix_varbit(varbit, varbit, int2, internal);
+DROP FUNCTION gin_extract_query_varbit(varbit, internal, int2, internal, internal);
+DROP FUNCTION gin_extract_value_numeric(numeric, internal);
+DROP FUNCTION gin_compare_prefix_numeric(numeric, numeric, int2, internal);
+DROP FUNCTION gin_extract_query_numeric(numeric, internal, int2, internal, internal);
+DROP FUNCTION gin_numeric_cmp(numeric, numeric);
diff --git a/doc/src/sgml/btree-gin.sgml b/doc/src/sgml/btree-gin.sgml
new file mode 100644
index 0000000000..d2142028eb
--- /dev/null
+++ b/doc/src/sgml/btree-gin.sgml
@@ -0,0 +1,58 @@
+<!-- $PostgreSQL: pgsql/doc/src/sgml/btree-gin.sgml,v 1.1 2009/03/25 23:20:01 tgl Exp $ -->
+
+<sect1 id="btree-gin">
+ <title>btree_gin</title>
+
+ <indexterm zone="btree-gin">
+  <primary>btree_gin</primary>
+ </indexterm>
+
+ <para>
+  <filename>btree_gin</> provides sample GIN operator classes that
+  implement B-Tree equivalent behavior for the data types
+  <type>int2</>, <type>int4</>, <type>int8</>, <type>float4</>,
+  <type>float8</>, <type>timestamp with time zone</>,
+  <type>timestamp without time zone</>, <type>time with time zone</>,
+  <type>time without time zone</>, <type>date</>, <type>interval</>,
+  <type>oid</>, <type>money</>, <type>"char"</>,
+  <type>varchar</>, <type>text</>, <type>bytea</>, <type>bit</>,
+  <type>varbit</>, <type>macaddr</>, <type>inet</>, and <type>cidr</>.
+ </para>
+
+ <para>
+  In general, these operator classes will not outperform the equivalent
+  standard btree index methods, and they lack one major feature of the
+  standard btree code: the ability to enforce uniqueness.  However,
+  they are useful for GIN testing and as a base for developing other
+  GIN operator classes.  Also, for queries that test both a GIN-indexable
+  column and a btree-indexable column, it might be more efficient to create
+  a multi-column GIN index that uses one of these opclasses than to create
+  two separate indexes that would have to be combined via bitmap ANDing.
+ </para>
+
+ <sect2>
+  <title>Example usage</title>
+
+<programlisting>
+CREATE TABLE test (a int4);
+-- create index
+CREATE INDEX testidx ON test USING gin (a);
+-- query
+SELECT * FROM test WHERE a &lt; 10;
+</programlisting>
+
+ </sect2>
+
+ <sect2>
+  <title>Authors</title>
+
+  <para>
+   Teodor Sigaev (<email>teodor@stack.net</email>) and
+   Oleg Bartunov (<email>oleg@sai.msu.su</email>).  See
+   <ulink url="http://www.sai.msu.su/~megera/oddmuse/index.cgi/Gin"></ulink>
+   for additional information.
+  </para>
+
+ </sect2>
+
+</sect1>
diff --git a/doc/src/sgml/contrib.sgml b/doc/src/sgml/contrib.sgml
index 89fb5314fe..9790eb60dd 100644
--- a/doc/src/sgml/contrib.sgml
+++ b/doc/src/sgml/contrib.sgml
@@ -1,4 +1,4 @@
-<!-- $PostgreSQL: pgsql/doc/src/sgml/contrib.sgml,v 1.11 2009/01/04 22:19:59 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/contrib.sgml,v 1.12 2009/03/25 23:20:01 tgl Exp $ -->
 
 <appendix id="contrib">
  <title>Additional Supplied Modules</title>
@@ -80,6 +80,7 @@ psql -d dbname -f <replaceable>SHAREDIR</>/contrib/<replaceable>module</>.sql
 
  &adminpack;
  &auto-explain;
+ &btree-gin;
  &btree-gist;
  &chkpass;
  &citext;
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index 273d5a0979..591f1e86da 100644
--- a/doc/src/sgml/filelist.sgml
+++ b/doc/src/sgml/filelist.sgml
@@ -1,4 +1,4 @@
-<!-- $PostgreSQL: pgsql/doc/src/sgml/filelist.sgml,v 1.59 2009/01/04 22:19:59 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/filelist.sgml,v 1.60 2009/03/25 23:20:01 tgl Exp $ -->
 
 <!entity history    SYSTEM "history.sgml">
 <!entity info       SYSTEM "info.sgml">
@@ -93,6 +93,7 @@
 <!entity contrib         SYSTEM "contrib.sgml">
 <!entity adminpack       SYSTEM "adminpack.sgml">
 <!entity auto-explain    SYSTEM "auto-explain.sgml">
+<!entity btree-gin       SYSTEM "btree-gin.sgml">
 <!entity btree-gist      SYSTEM "btree-gist.sgml">
 <!entity chkpass         SYSTEM "chkpass.sgml">
 <!entity citext          SYSTEM "citext.sgml">