Create btree_gist v1.9, in which inet/cidr opclasses aren't default.

btree_gist's gist_inet_ops and gist_cidr_ops opclasses are
fundamentally broken: they rely on an approximate representation of
the inet values and hence sometimes miss rows they should return.
We want to eventually get rid of them altogether, but as the first
step on that journey, we should mark them not-opcdefault.

To do that, roll up the preceding deltas since 1.2 into a new base
script btree_gist--1.9.sql.  This will allow installing 1.9 without
going through a transient situation where gist_inet_ops and
gist_cidr_ops are marked as opcdefault; trying to create them that
way will fail if there's already a matching default opclass in the
core system.  Additionally provide btree_gist--1.8--1.9.sql, so
that a database that's been pg_upgraded from an older version can
be migrated to 1.9.

I noted along the way that commit 57e3c5160 had missed marking the
gist_bool_ops support functions as PARALLEL SAFE.  While that probably
has little harmful effect (since AFAIK we don't check that when
calling index support functions), this seems like a good time to make
things consistent.

Readers will also note that I removed the former habit of installing
some opclass operators/functions with ALTER OPERATOR FAMILY, instead
just rolling them all into the CREATE OPERATOR CLASS steps.  The
comment in btree_gist--1.2.sql that it's necessary to use ALTER for
pg_upgrade reproducibility has been obsolete since we invented the
amadjustmembers infrastructure.  Nowadays, gistadjustmembers will
force all operators and non-required support functions to have "soft"
opfamily dependencies, regardless of whether they are installed by
CREATE or ALTER.

Author: Tom Lane <tgl@sss.pgh.pa.us>
Reviewed-by: Matthias van de Meent <boekewurm+postgres@gmail.com>
Reviewed-by: Heikki Linnakangas <hlinnaka@iki.fi>
Discussion: https://postgr.es/m/2483812.1754072263@sss.pgh.pa.us

diff --git a/contrib/btree_gist/Makefile b/contrib/btree_gist/Makefile
index 7ac2df26c1044a74a8152927795dd16d2016acd4..5161b42b69f0758e948ffba7ac9057c10f3d7a6c 100644 (file)
--- a/contrib/btree_gist/Makefile
+++ b/contrib/btree_gist/Makefile
@@ -34,7 +34,8 @@ DATA = btree_gist--1.0--1.1.sql \
        btree_gist--1.1--1.2.sql btree_gist--1.2.sql btree_gist--1.2--1.3.sql \
        btree_gist--1.3--1.4.sql btree_gist--1.4--1.5.sql \
        btree_gist--1.5--1.6.sql btree_gist--1.6--1.7.sql \
-       btree_gist--1.7--1.8.sql
+       btree_gist--1.7--1.8.sql btree_gist--1.8--1.9.sql \
+       btree_gist--1.9.sql
 PGFILEDESC = "btree_gist - B-tree equivalent GiST operator classes"
 
 REGRESS = init int2 int4 int8 float4 float8 cash oid timestamp timestamptz \

diff --git a/contrib/btree_gist/btree_gist--1.8--1.9.sql b/contrib/btree_gist/btree_gist--1.8--1.9.sql
new file mode 100644 (file)
index 0000000..c67812f
--- /dev/null
+++ b/contrib/btree_gist/btree_gist--1.8--1.9.sql
@@ -0,0 +1,40 @@
+/* contrib/btree_gist/btree_gist--1.8--1.9.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.9'" to load this file. \quit
+
+--
+-- Mark gist_inet_ops and gist_cidr_ops opclasses as non-default.
+-- This is the first step on the way to eventually removing them.
+--
+-- There's no SQL command for this, so fake it with a manual update on
+-- pg_opclass.
+--
+DO LANGUAGE plpgsql
+$$
+DECLARE
+  my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
+  old_path pg_catalog.text := pg_catalog.current_setting('search_path');
+BEGIN
+-- for safety, transiently set search_path to just pg_catalog+pg_temp
+PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
+
+UPDATE pg_catalog.pg_opclass
+SET opcdefault = false
+WHERE opcmethod = (SELECT oid FROM pg_catalog.pg_am WHERE amname = 'gist') AND
+      opcname IN ('gist_inet_ops', 'gist_cidr_ops') AND
+      opcnamespace = my_schema::pg_catalog.regnamespace;
+
+PERFORM pg_catalog.set_config('search_path', old_path, true);
+END
+$$;
+
+
+-- Fix parallel-safety markings overlooked in btree_gist--1.6--1.7.sql.
+ALTER FUNCTION gbt_bool_consistent(internal, bool, smallint, oid, internal) PARALLEL SAFE;
+ALTER FUNCTION gbt_bool_compress(internal) PARALLEL SAFE;
+ALTER FUNCTION gbt_bool_fetch(internal) PARALLEL SAFE;
+ALTER FUNCTION gbt_bool_penalty(internal, internal, internal) PARALLEL SAFE;
+ALTER FUNCTION gbt_bool_picksplit(internal, internal) PARALLEL SAFE;
+ALTER FUNCTION gbt_bool_union(internal, internal) PARALLEL SAFE;
+ALTER FUNCTION gbt_bool_same(gbtreekey2, gbtreekey2, internal) PARALLEL SAFE;

diff --git a/contrib/btree_gist/btree_gist--1.9.sql b/contrib/btree_gist/btree_gist--1.9.sql
new file mode 100644 (file)
index 0000000..504de91
--- /dev/null
+++ b/contrib/btree_gist/btree_gist--1.9.sql
@@ -0,0 +1,1971 @@
+/* contrib/btree_gist/btree_gist--1.9.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION btree_gist" to load this file. \quit
+
+CREATE FUNCTION gbtreekey2_in(cstring)
+RETURNS gbtreekey2
+AS 'MODULE_PATHNAME', 'gbtreekey_in'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbtreekey2_out(gbtreekey2)
+RETURNS cstring
+AS 'MODULE_PATHNAME', 'gbtreekey_out'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE gbtreekey2 (
+       INTERNALLENGTH = 2,
+       INPUT  = gbtreekey2_in,
+       OUTPUT = gbtreekey2_out
+);
+
+CREATE FUNCTION gbtreekey4_in(cstring)
+RETURNS gbtreekey4
+AS 'MODULE_PATHNAME', 'gbtreekey_in'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbtreekey4_out(gbtreekey4)
+RETURNS cstring
+AS 'MODULE_PATHNAME', 'gbtreekey_out'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE gbtreekey4 (
+       INTERNALLENGTH = 4,
+       INPUT  = gbtreekey4_in,
+       OUTPUT = gbtreekey4_out
+);
+
+CREATE FUNCTION gbtreekey8_in(cstring)
+RETURNS gbtreekey8
+AS 'MODULE_PATHNAME', 'gbtreekey_in'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbtreekey8_out(gbtreekey8)
+RETURNS cstring
+AS 'MODULE_PATHNAME', 'gbtreekey_out'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE gbtreekey8 (
+       INTERNALLENGTH = 8,
+       INPUT  = gbtreekey8_in,
+       OUTPUT = gbtreekey8_out
+);
+
+CREATE FUNCTION gbtreekey16_in(cstring)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME', 'gbtreekey_in'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbtreekey16_out(gbtreekey16)
+RETURNS cstring
+AS 'MODULE_PATHNAME', 'gbtreekey_out'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE gbtreekey16 (
+       INTERNALLENGTH = 16,
+       INPUT  = gbtreekey16_in,
+       OUTPUT = gbtreekey16_out
+);
+
+CREATE FUNCTION gbtreekey32_in(cstring)
+RETURNS gbtreekey32
+AS 'MODULE_PATHNAME', 'gbtreekey_in'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbtreekey32_out(gbtreekey32)
+RETURNS cstring
+AS 'MODULE_PATHNAME', 'gbtreekey_out'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE gbtreekey32 (
+       INTERNALLENGTH = 32,
+       INPUT  = gbtreekey32_in,
+       OUTPUT = gbtreekey32_out
+);
+
+CREATE FUNCTION gbtreekey_var_in(cstring)
+RETURNS gbtreekey_var
+AS 'MODULE_PATHNAME', 'gbtreekey_in'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbtreekey_var_out(gbtreekey_var)
+RETURNS cstring
+AS 'MODULE_PATHNAME', 'gbtreekey_out'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE gbtreekey_var (
+       INTERNALLENGTH = VARIABLE,
+       INPUT  = gbtreekey_var_in,
+       OUTPUT = gbtreekey_var_out,
+       STORAGE = EXTENDED
+);
+
+--common support functions
+
+CREATE FUNCTION gist_translate_cmptype_btree(int)
+RETURNS smallint
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+--distance operators
+
+CREATE FUNCTION cash_dist(money, money)
+RETURNS money
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = money,
+       RIGHTARG = money,
+       PROCEDURE = cash_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION date_dist(date, date)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = date,
+       RIGHTARG = date,
+       PROCEDURE = date_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION float4_dist(float4, float4)
+RETURNS float4
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = float4,
+       RIGHTARG = float4,
+       PROCEDURE = float4_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION float8_dist(float8, float8)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = float8,
+       RIGHTARG = float8,
+       PROCEDURE = float8_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION int2_dist(int2, int2)
+RETURNS int2
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = int2,
+       RIGHTARG = int2,
+       PROCEDURE = int2_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION int4_dist(int4, int4)
+RETURNS int4
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = int4,
+       RIGHTARG = int4,
+       PROCEDURE = int4_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION int8_dist(int8, int8)
+RETURNS int8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = int8,
+       RIGHTARG = int8,
+       PROCEDURE = int8_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION interval_dist(interval, interval)
+RETURNS interval
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = interval,
+       RIGHTARG = interval,
+       PROCEDURE = interval_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION oid_dist(oid, oid)
+RETURNS oid
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = oid,
+       RIGHTARG = oid,
+       PROCEDURE = oid_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION time_dist(time, time)
+RETURNS interval
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = time,
+       RIGHTARG = time,
+       PROCEDURE = time_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION ts_dist(timestamp, timestamp)
+RETURNS interval
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = timestamp,
+       RIGHTARG = timestamp,
+       PROCEDURE = ts_dist,
+       COMMUTATOR = '<->'
+);
+
+CREATE FUNCTION tstz_dist(timestamptz, timestamptz)
+RETURNS interval
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <-> (
+       LEFTARG = timestamptz,
+       RIGHTARG = timestamptz,
+       PROCEDURE = tstz_dist,
+       COMMUTATOR = '<->'
+);
+
+
+--
+--
+--
+-- oid ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_oid_consistent(internal,oid,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_distance(internal,oid,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_decompress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_var_decompress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_var_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_union(internal, internal)
+RETURNS gbtreekey8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_same(gbtreekey8, gbtreekey8, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_oid_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_oid_ops
+DEFAULT FOR TYPE oid USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.oid_ops ,
+       FUNCTION        1       gbt_oid_consistent (internal, oid, int2, oid, internal),
+       FUNCTION        2       gbt_oid_union (internal, internal),
+       FUNCTION        3       gbt_oid_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_oid_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_oid_picksplit (internal, internal),
+       FUNCTION        7       gbt_oid_same (gbtreekey8, gbtreekey8, internal),
+       FUNCTION        8       gbt_oid_distance (internal, oid, int2, oid, internal),
+       FUNCTION        9       gbt_oid_fetch (internal),
+       FUNCTION        11      gbt_oid_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey8;
+
+
+--
+--
+--
+-- int2 ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_int2_consistent(internal,int2,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_distance(internal,int2,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_union(internal, internal)
+RETURNS gbtreekey4
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_same(gbtreekey4, gbtreekey4, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int2_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_int2_ops
+DEFAULT FOR TYPE int2 USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.integer_ops ,
+       FUNCTION        1       gbt_int2_consistent (internal, int2, int2, oid, internal),
+       FUNCTION        2       gbt_int2_union (internal, internal),
+       FUNCTION        3       gbt_int2_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_int2_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_int2_picksplit (internal, internal),
+       FUNCTION        7       gbt_int2_same (gbtreekey4, gbtreekey4, internal),
+       FUNCTION        8       gbt_int2_distance (internal, int2, int2, oid, internal),
+       FUNCTION        9       gbt_int2_fetch (internal),
+       FUNCTION        11      gbt_int2_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey4;
+
+
+--
+--
+--
+-- int4 ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_int4_consistent(internal,int4,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_distance(internal,int4,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_union(internal, internal)
+RETURNS gbtreekey8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_same(gbtreekey8, gbtreekey8, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int4_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_int4_ops
+DEFAULT FOR TYPE int4 USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.integer_ops ,
+       FUNCTION        1       gbt_int4_consistent (internal, int4, int2, oid, internal),
+       FUNCTION        2       gbt_int4_union (internal, internal),
+       FUNCTION        3       gbt_int4_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_int4_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_int4_picksplit (internal, internal),
+       FUNCTION        7       gbt_int4_same (gbtreekey8, gbtreekey8, internal),
+       FUNCTION        8       gbt_int4_distance (internal, int4, int2, oid, internal),
+       FUNCTION        9       gbt_int4_fetch (internal),
+       FUNCTION        11      gbt_int4_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey8;
+
+
+--
+--
+--
+-- int8 ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_int8_consistent(internal,int8,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_distance(internal,int8,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_int8_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_int8_ops
+DEFAULT FOR TYPE int8 USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.integer_ops ,
+       FUNCTION        1       gbt_int8_consistent (internal, int8, int2, oid, internal),
+       FUNCTION        2       gbt_int8_union (internal, internal),
+       FUNCTION        3       gbt_int8_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_int8_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_int8_picksplit (internal, internal),
+       FUNCTION        7       gbt_int8_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        8       gbt_int8_distance (internal, int8, int2, oid, internal),
+       FUNCTION        9       gbt_int8_fetch (internal),
+       FUNCTION        11      gbt_int8_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- float4 ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_float4_consistent(internal,float4,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_distance(internal,float4,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_union(internal, internal)
+RETURNS gbtreekey8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_same(gbtreekey8, gbtreekey8, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float4_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_float4_ops
+DEFAULT FOR TYPE float4 USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.float_ops ,
+       FUNCTION        1       gbt_float4_consistent (internal, float4, int2, oid, internal),
+       FUNCTION        2       gbt_float4_union (internal, internal),
+       FUNCTION        3       gbt_float4_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_float4_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_float4_picksplit (internal, internal),
+       FUNCTION        7       gbt_float4_same (gbtreekey8, gbtreekey8, internal),
+       FUNCTION        8       gbt_float4_distance (internal, float4, int2, oid, internal),
+       FUNCTION        9       gbt_float4_fetch (internal),
+       FUNCTION        11      gbt_float4_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey8;
+
+
+--
+--
+--
+-- float8 ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_float8_consistent(internal,float8,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_distance(internal,float8,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_float8_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_float8_ops
+DEFAULT FOR TYPE float8 USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.float_ops ,
+       FUNCTION        1       gbt_float8_consistent (internal, float8, int2, oid, internal),
+       FUNCTION        2       gbt_float8_union (internal, internal),
+       FUNCTION        3       gbt_float8_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_float8_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_float8_picksplit (internal, internal),
+       FUNCTION        7       gbt_float8_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        8       gbt_float8_distance (internal, float8, int2, oid, internal),
+       FUNCTION        9       gbt_float8_fetch (internal),
+       FUNCTION        11      gbt_float8_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- timestamp ops
+--
+--
+--
+
+CREATE FUNCTION gbt_ts_consistent(internal,timestamp,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_distance(internal,timestamp,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_tstz_distance(internal,timestamptz,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_tstz_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_ts_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_timestamp_ops
+DEFAULT FOR TYPE timestamp USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.interval_ops ,
+       FUNCTION        1       gbt_ts_consistent (internal, timestamp, int2, oid, internal),
+       FUNCTION        2       gbt_ts_union (internal, internal),
+       FUNCTION        3       gbt_ts_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_ts_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_ts_picksplit (internal, internal),
+       FUNCTION        7       gbt_ts_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        8       gbt_ts_distance (internal, timestamp, int2, oid, internal),
+       FUNCTION        9       gbt_ts_fetch (internal),
+       FUNCTION        11      gbt_ts_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_timestamptz_ops
+DEFAULT FOR TYPE timestamptz USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.interval_ops ,
+       FUNCTION        1       gbt_tstz_consistent (internal, timestamptz, int2, oid, internal),
+       FUNCTION        2       gbt_ts_union (internal, internal),
+       FUNCTION        3       gbt_tstz_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_ts_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_ts_picksplit (internal, internal),
+       FUNCTION        7       gbt_ts_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        8       gbt_tstz_distance (internal, timestamptz, int2, oid, internal),
+       FUNCTION        9       gbt_ts_fetch (internal),
+       FUNCTION        11      gbt_ts_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- time ops
+--
+--
+--
+
+CREATE FUNCTION gbt_time_consistent(internal,time,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_distance(internal,time,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_timetz_consistent(internal,timetz,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_timetz_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_time_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_time_ops
+DEFAULT FOR TYPE time USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.interval_ops ,
+       FUNCTION        1       gbt_time_consistent (internal, time, int2, oid, internal),
+       FUNCTION        2       gbt_time_union (internal, internal),
+       FUNCTION        3       gbt_time_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_time_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_time_picksplit (internal, internal),
+       FUNCTION        7       gbt_time_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        8       gbt_time_distance (internal, time, int2, oid, internal),
+       FUNCTION        9       gbt_time_fetch (internal),
+       FUNCTION        11      gbt_time_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+CREATE OPERATOR CLASS gist_timetz_ops
+DEFAULT FOR TYPE timetz USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_timetz_consistent (internal, timetz, int2, oid, internal),
+       FUNCTION        2       gbt_time_union (internal, internal),
+       FUNCTION        3       gbt_timetz_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_time_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_time_picksplit (internal, internal),
+       FUNCTION        7       gbt_time_same (gbtreekey16, gbtreekey16, internal),
+       -- no 'fetch' function, as the compress function is lossy.
+       FUNCTION        11      gbt_time_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- date ops
+--
+--
+--
+
+CREATE FUNCTION gbt_date_consistent(internal,date,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_distance(internal,date,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_union(internal, internal)
+RETURNS gbtreekey8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_same(gbtreekey8, gbtreekey8, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_date_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_date_ops
+DEFAULT FOR TYPE date USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.integer_ops ,
+       FUNCTION        1       gbt_date_consistent (internal, date, int2, oid, internal),
+       FUNCTION        2       gbt_date_union (internal, internal),
+       FUNCTION        3       gbt_date_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_date_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_date_picksplit (internal, internal),
+       FUNCTION        7       gbt_date_same (gbtreekey8, gbtreekey8, internal),
+       FUNCTION        8       gbt_date_distance (internal, date, int2, oid, internal),
+       FUNCTION        9       gbt_date_fetch (internal),
+       FUNCTION        11      gbt_date_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey8;
+
+
+--
+--
+--
+-- interval ops
+--
+--
+--
+
+CREATE FUNCTION gbt_intv_consistent(internal,interval,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_distance(internal,interval,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_decompress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_union(internal, internal)
+RETURNS gbtreekey32
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_same(gbtreekey32, gbtreekey32, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_intv_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_interval_ops
+DEFAULT FOR TYPE interval USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.interval_ops ,
+       FUNCTION        1       gbt_intv_consistent (internal, interval, int2, oid, internal),
+       FUNCTION        2       gbt_intv_union (internal, internal),
+       FUNCTION        3       gbt_intv_compress (internal),
+       FUNCTION        4       gbt_intv_decompress (internal),
+       FUNCTION        5       gbt_intv_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_intv_picksplit (internal, internal),
+       FUNCTION        7       gbt_intv_same (gbtreekey32, gbtreekey32, internal),
+       FUNCTION        8       gbt_intv_distance (internal, interval, int2, oid, internal),
+       FUNCTION        9       gbt_intv_fetch (internal),
+       FUNCTION        11      gbt_intv_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey32;
+
+
+--
+--
+--
+-- cash ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_cash_consistent(internal,money,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_distance(internal,money,int2,oid,internal)
+RETURNS float8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_cash_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_cash_ops
+DEFAULT FOR TYPE money USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       OPERATOR        15      <-> FOR ORDER BY pg_catalog.money_ops ,
+       FUNCTION        1       gbt_cash_consistent (internal, money, int2, oid, internal),
+       FUNCTION        2       gbt_cash_union (internal, internal),
+       FUNCTION        3       gbt_cash_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_cash_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_cash_picksplit (internal, internal),
+       FUNCTION        7       gbt_cash_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        8       gbt_cash_distance (internal, money, int2, oid, internal),
+       FUNCTION        9       gbt_cash_fetch (internal),
+       FUNCTION        11      gbt_cash_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- macaddr ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_macad_consistent(internal,macaddr,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macaddr_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_macaddr_ops
+DEFAULT FOR TYPE macaddr USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_macad_consistent (internal, macaddr, int2, oid, internal),
+       FUNCTION        2       gbt_macad_union (internal, internal),
+       FUNCTION        3       gbt_macad_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_macad_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_macad_picksplit (internal, internal),
+       FUNCTION        7       gbt_macad_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        9       gbt_macad_fetch (internal),
+       FUNCTION        11      gbt_macaddr_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- text/bpchar ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_text_consistent(internal,text,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_text_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bpchar_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_text_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_text_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_text_union(internal, internal)
+RETURNS gbtreekey_var
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_text_same(gbtreekey_var, gbtreekey_var, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_text_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bpchar_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_text_ops
+DEFAULT FOR TYPE text USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_text_consistent (internal, text, int2, oid, internal),
+       FUNCTION        2       gbt_text_union (internal, internal),
+       FUNCTION        3       gbt_text_compress (internal),
+       FUNCTION        4       gbt_var_decompress (internal),
+       FUNCTION        5       gbt_text_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_text_picksplit (internal, internal),
+       FUNCTION        7       gbt_text_same (gbtreekey_var, gbtreekey_var, internal),
+       FUNCTION        9       gbt_var_fetch (internal),
+       FUNCTION        11      gbt_text_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE                 gbtreekey_var;
+
+---- Create the operator class
+CREATE OPERATOR CLASS gist_bpchar_ops
+DEFAULT FOR TYPE bpchar USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_bpchar_consistent (internal, bpchar , int2, oid, internal),
+       FUNCTION        2       gbt_text_union (internal, internal),
+       FUNCTION        3       gbt_bpchar_compress (internal),
+       FUNCTION        4       gbt_var_decompress (internal),
+       FUNCTION        5       gbt_text_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_text_picksplit (internal, internal),
+       FUNCTION        7       gbt_text_same (gbtreekey_var, gbtreekey_var, internal),
+       FUNCTION        9       gbt_var_fetch (internal),
+       FUNCTION        11      gbt_bpchar_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE                 gbtreekey_var;
+
+
+--
+--
+-- bytea ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_bytea_consistent(internal,bytea,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bytea_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bytea_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bytea_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bytea_union(internal, internal)
+RETURNS gbtreekey_var
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bytea_same(gbtreekey_var, gbtreekey_var, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bytea_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_bytea_ops
+DEFAULT FOR TYPE bytea USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_bytea_consistent (internal, bytea, int2, oid, internal),
+       FUNCTION        2       gbt_bytea_union (internal, internal),
+       FUNCTION        3       gbt_bytea_compress (internal),
+       FUNCTION        4       gbt_var_decompress (internal),
+       FUNCTION        5       gbt_bytea_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_bytea_picksplit (internal, internal),
+       FUNCTION        7       gbt_bytea_same (gbtreekey_var, gbtreekey_var, internal),
+       FUNCTION        9       gbt_var_fetch (internal),
+       FUNCTION        11      gbt_bytea_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE                 gbtreekey_var;
+
+
+--
+--
+--
+-- numeric ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_numeric_consistent(internal,numeric,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_numeric_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_numeric_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_numeric_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_numeric_union(internal, internal)
+RETURNS gbtreekey_var
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_numeric_same(gbtreekey_var, gbtreekey_var, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_numeric_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_numeric_ops
+DEFAULT FOR TYPE numeric USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_numeric_consistent (internal, numeric, int2, oid, internal),
+       FUNCTION        2       gbt_numeric_union (internal, internal),
+       FUNCTION        3       gbt_numeric_compress (internal),
+       FUNCTION        4       gbt_var_decompress (internal),
+       FUNCTION        5       gbt_numeric_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_numeric_picksplit (internal, internal),
+       FUNCTION        7       gbt_numeric_same (gbtreekey_var, gbtreekey_var, internal),
+       FUNCTION        9       gbt_var_fetch (internal),
+       FUNCTION        11      gbt_numeric_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE                 gbtreekey_var;
+
+
+--
+--
+-- bit ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_bit_consistent(internal,bit,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bit_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bit_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bit_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bit_union(internal, internal)
+RETURNS gbtreekey_var
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bit_same(gbtreekey_var, gbtreekey_var, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bit_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_varbit_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_bit_ops
+DEFAULT FOR TYPE bit USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_bit_consistent (internal, bit, int2, oid, internal),
+       FUNCTION        2       gbt_bit_union (internal, internal),
+       FUNCTION        3       gbt_bit_compress (internal),
+       FUNCTION        4       gbt_var_decompress (internal),
+       FUNCTION        5       gbt_bit_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_bit_picksplit (internal, internal),
+       FUNCTION        7       gbt_bit_same (gbtreekey_var, gbtreekey_var, internal),
+       FUNCTION        9       gbt_var_fetch (internal),
+       FUNCTION        11      gbt_bit_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE                 gbtreekey_var;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_vbit_ops
+DEFAULT FOR TYPE varbit USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_bit_consistent (internal, bit, int2, oid, internal),
+       FUNCTION        2       gbt_bit_union (internal, internal),
+       FUNCTION        3       gbt_bit_compress (internal),
+       FUNCTION        4       gbt_var_decompress (internal),
+       FUNCTION        5       gbt_bit_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_bit_picksplit (internal, internal),
+       FUNCTION        7       gbt_bit_same (gbtreekey_var, gbtreekey_var, internal),
+       FUNCTION        9       gbt_var_fetch (internal),
+       FUNCTION        11      gbt_varbit_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE                 gbtreekey_var;
+
+
+--
+--
+--
+-- inet/cidr ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_inet_consistent(internal,inet,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_inet_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_inet_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_inet_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_inet_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_inet_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_inet_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class (intentionally not DEFAULT)
+CREATE OPERATOR CLASS gist_inet_ops
+FOR TYPE inet USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_inet_consistent (internal, inet, int2, oid, internal),
+       FUNCTION        2       gbt_inet_union (internal, internal),
+       FUNCTION        3       gbt_inet_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_inet_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_inet_picksplit (internal, internal),
+       FUNCTION        7       gbt_inet_same (gbtreekey16, gbtreekey16, internal),
+       -- no fetch support, the compress function is lossy
+       FUNCTION        11      gbt_inet_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+-- Create the operator class (intentionally not DEFAULT)
+CREATE OPERATOR CLASS gist_cidr_ops
+FOR TYPE cidr USING gist
+AS
+       OPERATOR        1       <  (inet, inet) ,
+       OPERATOR        2       <= (inet, inet) ,
+       OPERATOR        3       =  (inet, inet) ,
+       OPERATOR        4       >= (inet, inet) ,
+       OPERATOR        5       >  (inet, inet) ,
+       OPERATOR        6       <> (inet, inet) ,
+       FUNCTION        1       gbt_inet_consistent (internal, inet, int2, oid, internal),
+       FUNCTION        2       gbt_inet_union (internal, internal),
+       FUNCTION        3       gbt_inet_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_inet_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_inet_picksplit (internal, internal),
+       FUNCTION        7       gbt_inet_same (gbtreekey16, gbtreekey16, internal),
+       -- no fetch support, the compress function is lossy
+       FUNCTION        11      gbt_inet_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- uuid ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_uuid_consistent(internal,uuid,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_uuid_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_uuid_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_uuid_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_uuid_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_uuid_union(internal, internal)
+RETURNS gbtreekey32
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_uuid_same(gbtreekey32, gbtreekey32, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_uuid_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_uuid_ops
+DEFAULT FOR TYPE uuid USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_uuid_consistent (internal, uuid, int2, oid, internal),
+       FUNCTION        2       gbt_uuid_union (internal, internal),
+       FUNCTION        3       gbt_uuid_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_uuid_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_uuid_picksplit (internal, internal),
+       FUNCTION        7       gbt_uuid_same (gbtreekey32, gbtreekey32, internal),
+       FUNCTION        9       gbt_uuid_fetch (internal),
+       FUNCTION        11      gbt_uuid_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey32;
+
+
+--
+--
+--
+-- macaddr8 ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_macad8_consistent(internal,macaddr8,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad8_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad8_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad8_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad8_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad8_union(internal, internal)
+RETURNS gbtreekey16
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad8_same(gbtreekey16, gbtreekey16, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_macad8_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_macaddr8_ops
+DEFAULT FOR TYPE macaddr8 USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_macad8_consistent (internal, macaddr8, int2, oid, internal),
+       FUNCTION        2       gbt_macad8_union (internal, internal),
+       FUNCTION        3       gbt_macad8_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_macad8_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_macad8_picksplit (internal, internal),
+       FUNCTION        7       gbt_macad8_same (gbtreekey16, gbtreekey16, internal),
+       FUNCTION        9       gbt_macad8_fetch (internal),
+       FUNCTION        11      gbt_macad8_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey16;
+
+
+--
+--
+--
+-- enum ops
+--
+--
+--
+-- define the GiST support methods
+CREATE FUNCTION gbt_enum_consistent(internal,anyenum,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_enum_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_enum_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_enum_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_enum_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_enum_union(internal, internal)
+RETURNS gbtreekey8
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_enum_same(gbtreekey8, gbtreekey8, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_enum_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_enum_ops
+DEFAULT FOR TYPE anyenum USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_enum_consistent (internal, anyenum, int2, oid, internal),
+       FUNCTION        2       gbt_enum_union (internal, internal),
+       FUNCTION        3       gbt_enum_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_enum_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_enum_picksplit (internal, internal),
+       FUNCTION        7       gbt_enum_same (gbtreekey8, gbtreekey8, internal),
+       FUNCTION        9       gbt_enum_fetch (internal),
+       FUNCTION        11      gbt_enum_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey8;
+
+
+--
+--
+--
+-- bool ops
+--
+--
+--
+-- Define the GiST support methods
+CREATE FUNCTION gbt_bool_consistent(internal,bool,int2,oid,internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bool_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bool_fetch(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bool_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bool_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bool_union(internal, internal)
+RETURNS gbtreekey2
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bool_same(gbtreekey2, gbtreekey2, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION gbt_bool_sortsupport(internal)
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- Create the operator class
+CREATE OPERATOR CLASS gist_bool_ops
+DEFAULT FOR TYPE bool USING gist
+AS
+       OPERATOR        1       <  ,
+       OPERATOR        2       <= ,
+       OPERATOR        3       =  ,
+       OPERATOR        4       >= ,
+       OPERATOR        5       >  ,
+       OPERATOR        6       <> ,
+       FUNCTION        1       gbt_bool_consistent (internal, bool, int2, oid, internal),
+       FUNCTION        2       gbt_bool_union (internal, internal),
+       FUNCTION        3       gbt_bool_compress (internal),
+       FUNCTION        4       gbt_decompress (internal),
+       FUNCTION        5       gbt_bool_penalty (internal, internal, internal),
+       FUNCTION        6       gbt_bool_picksplit (internal, internal),
+       FUNCTION        7       gbt_bool_same (gbtreekey2, gbtreekey2, internal),
+       FUNCTION        9       gbt_bool_fetch (internal),
+       FUNCTION        11      gbt_bool_sortsupport (internal),
+       FUNCTION        12 ("any", "any") gist_translate_cmptype_btree (int),
+       STORAGE         gbtreekey2;

diff --git a/contrib/btree_gist/btree_gist.control b/contrib/btree_gist/btree_gist.control
index abf66538f32443b23e1f2a28bc9541f9d27e4883..69d9341a0adea05f1b1b24f78adc5498e4985125 100644 (file)
--- a/contrib/btree_gist/btree_gist.control
+++ b/contrib/btree_gist/btree_gist.control
@@ -1,6 +1,6 @@
 # btree_gist extension
 comment = 'support for indexing common datatypes in GiST'
-default_version = '1.8'
+default_version = '1.9'
 module_pathname = '$libdir/btree_gist'
 relocatable = true
 trusted = true

diff --git a/contrib/btree_gist/expected/cidr.out b/contrib/btree_gist/expected/cidr.out
index 6d0995add60ec54d3a23e76a6baad98120f15ee0..e61df27affc71a662fc7980759db957793d972e6 100644 (file)
--- a/contrib/btree_gist/expected/cidr.out
+++ b/contrib/btree_gist/expected/cidr.out
@@ -32,7 +32,7 @@ SELECT count(*) FROM cidrtmp WHERE a >  '121.111.63.82';
    309
 (1 row)
 
-CREATE INDEX cidridx ON cidrtmp USING gist ( a );
+CREATE INDEX cidridx ON cidrtmp USING gist ( a gist_cidr_ops );
 SET enable_seqscan=off;
 SELECT count(*) FROM cidrtmp WHERE a <  '121.111.63.82'::cidr;
  count 

diff --git a/contrib/btree_gist/expected/inet.out b/contrib/btree_gist/expected/inet.out
index f15f1435f0ab2270e9c4c8f81288be8e2395d421..8cf12e3df8e0b958c2a6803ceef8328d5233594b 100644 (file)
--- a/contrib/btree_gist/expected/inet.out
+++ b/contrib/btree_gist/expected/inet.out
@@ -32,7 +32,7 @@ SELECT count(*) FROM inettmp WHERE a >  '89.225.196.191';
    386
 (1 row)
 
-CREATE INDEX inetidx ON inettmp USING gist ( a );
+CREATE INDEX inetidx ON inettmp USING gist ( a gist_inet_ops );
 SET enable_seqscan=off;
 SELECT count(*) FROM inettmp WHERE a <  '89.225.196.191'::inet;
  count 

diff --git a/contrib/btree_gist/meson.build b/contrib/btree_gist/meson.build
index 5a58ed5a7e7ec2e69154efe3ded7f2845f0083ae..796bcbe4c01b6ebc5ec53c1a90cd5a16962a1877 100644 (file)
--- a/contrib/btree_gist/meson.build
+++ b/contrib/btree_gist/meson.build
@@ -51,6 +51,8 @@ install_data(
   'btree_gist--1.5--1.6.sql',
   'btree_gist--1.6--1.7.sql',
   'btree_gist--1.7--1.8.sql',
+  'btree_gist--1.8--1.9.sql',
+  'btree_gist--1.9.sql',
   kwargs: contrib_data_args,
 )
 

diff --git a/contrib/btree_gist/sql/cidr.sql b/contrib/btree_gist/sql/cidr.sql
index 9bd77185b96a8ec9913ff15f7927b787a733dbb4..ec1529e3e04d49bee8053ea4f502ea67d91bb306 100644 (file)
--- a/contrib/btree_gist/sql/cidr.sql
+++ b/contrib/btree_gist/sql/cidr.sql
@@ -15,7 +15,7 @@ SELECT count(*) FROM cidrtmp WHERE a >= '121.111.63.82';
 
 SELECT count(*) FROM cidrtmp WHERE a >  '121.111.63.82';
 
-CREATE INDEX cidridx ON cidrtmp USING gist ( a );
+CREATE INDEX cidridx ON cidrtmp USING gist ( a gist_cidr_ops );
 
 SET enable_seqscan=off;
 

diff --git a/contrib/btree_gist/sql/inet.sql b/contrib/btree_gist/sql/inet.sql
index 249e8085c3b3b6487be8db2adab8bed89f894c85..0bb73c9d715800b6450e2fdb1b05cfd7a7e10b50 100644 (file)
--- a/contrib/btree_gist/sql/inet.sql
+++ b/contrib/btree_gist/sql/inet.sql
@@ -16,7 +16,7 @@ SELECT count(*) FROM inettmp WHERE a >= '89.225.196.191';
 
 SELECT count(*) FROM inettmp WHERE a >  '89.225.196.191';
 
-CREATE INDEX inetidx ON inettmp USING gist ( a );
+CREATE INDEX inetidx ON inettmp USING gist ( a gist_inet_ops );
 
 SET enable_seqscan=off;