Skip to content

P
Postgres FD Implementation
Commit fdc9186f authored by Tom Lane's avatar Tom Lane
Browse files
Options

Replace the built-in GIN array opclasses with a single polymorphic opclass. 

We had thirty different GIN array opclasses sharing the same operators and
support functions.  That still didn't cover all the built-in types, nor
did it cover arrays of extension-added types.  What we want is a single
polymorphic opclass for "anyarray".  There were two missing features needed
to make this possible:

1. We have to be able to declare the index storage type as ANYELEMENT
when the opclass is declared to index ANYARRAY.  This just takes a few
more lines in index_create().  Although this currently seems of use only
for GIN, there's no reason to make index_create() restrict it to that.

2. We have to be able to identify the proper GIN compare function for
the index storage type.  This patch proceeds by making the compare function
optional in GIN opclass definitions, and specifying that the default btree
comparison function for the index storage type will be looked up when the
opclass omits it.  Again, that seems pretty generically useful.

Since the comparison function lookup is done in initGinState(), making
use of the second feature adds an additional cache lookup to GIN index
access setup.  It seems unlikely that that would be very noticeable given
the other costs involved, but maybe at some point we should consider
making GinState data persist longer than it now does --- we could keep it
in the index relcache entry, perhaps.

Rather fortuitously, we don't seem to need to do anything to get this
change to play nice with dump/reload or pg_upgrade scenarios: the new
opclass definition is automatically selected to replace existing index
definitions, and the on-disk data remains compatible.  Also, if a user has
created a custom opclass definition for a non-builtin type, this doesn't
break that, since CREATE INDEX will prefer an exact match to opcintype
over a match to ANYARRAY.  However, if there's anyone out there with
handwritten DDL that explicitly specifies _bool_ops or one of the other
replaced opclass names, they'll need to adjust that.

Tom Lane, reviewed by Enrique Meneses

Discussion: <14436.1470940379@sss.pgh.pa.us>
parent a4afb2b5
Hide whitespace changes
Inline Side-by-side
Showing with 101 additions and 503 deletions
doc/src/sgml/gin.sgml
View file @ fdc9186f
......@@ -85,298 +85,8 @@
</thead>
<tbody>
<row>
<entry><literal>_abstime_ops</></entry>
<entry><type>abstime[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_bit_ops</></entry>
<entry><type>bit[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_bool_ops</></entry>
<entry><type>boolean[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_bpchar_ops</></entry>
<entry><type>character[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_bytea_ops</></entry>
<entry><type>bytea[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_char_ops</></entry>
<entry><type>"char"[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_cidr_ops</></entry>
<entry><type>cidr[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_date_ops</></entry>
<entry><type>date[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_float4_ops</></entry>
<entry><type>float4[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_float8_ops</></entry>
<entry><type>float8[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_inet_ops</></entry>
<entry><type>inet[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_int2_ops</></entry>
<entry><type>smallint[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_int4_ops</></entry>
<entry><type>integer[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_int8_ops</></entry>
<entry><type>bigint[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_interval_ops</></entry>
<entry><type>interval[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_macaddr_ops</></entry>
<entry><type>macaddr[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_money_ops</></entry>
<entry><type>money[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_name_ops</></entry>
<entry><type>name[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_numeric_ops</></entry>
<entry><type>numeric[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_oid_ops</></entry>
<entry><type>oid[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_oidvector_ops</></entry>
<entry><type>oidvector[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_reltime_ops</></entry>
<entry><type>reltime[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_text_ops</></entry>
<entry><type>text[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_time_ops</></entry>
<entry><type>time[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_timestamp_ops</></entry>
<entry><type>timestamp[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_timestamptz_ops</></entry>
<entry><type>timestamp with time zone[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_timetz_ops</></entry>
<entry><type>time with time zone[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_tinterval_ops</></entry>
<entry><type>tinterval[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_varbit_ops</></entry>
<entry><type>bit varying[]</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
<literal>=</>
<literal>@&gt;</>
</entry>
</row>
<row>
<entry><literal>_varchar_ops</></entry>
<entry><type>character varying[]</></entry>
<entry><literal>array_ops</></entry>
<entry><type>anyarray</></entry>
<entry>
<literal>&amp;&amp;</>
<literal>&lt;@</>
......@@ -441,22 +151,10 @@
</para>
<para>
There are three methods that an operator class for
There are two methods that an operator class for
<acronym>GIN</acronym> must provide:
<variablelist>
<varlistentry>
<term><function>int compare(Datum a, Datum b)</></term>
<listitem>
<para>
Compares two keys (not indexed items!) and returns an integer less than
zero, zero, or greater than zero, indicating whether the first key is
less than, equal to, or greater than the second. Null keys are never
passed to this function.
</para>
</listitem>
</varlistentry>
<variablelist>
<varlistentry>
<term><function>Datum *extractValue(Datum itemValue, int32 *nkeys,
bool **nullFlags)</></term>
......@@ -645,7 +343,38 @@
</listitem>
</varlistentry>
</variablelist>
</para>
<para>
In addition, GIN must have a way to sort the key values stored in the index.
The operator class can define the sort ordering by specifying a comparison
method:
<variablelist>
<varlistentry>
<term><function>int compare(Datum a, Datum b)</></term>
<listitem>
<para>
Compares two keys (not indexed items!) and returns an integer less than
zero, zero, or greater than zero, indicating whether the first key is
less than, equal to, or greater than the second. Null keys are never
passed to this function.
</para>
</listitem>
</varlistentry>
</variablelist>
Alternatively, if the operator class does not provide a <function>compare</>
method, GIN will look up the default btree operator class for the index
key data type, and use its comparison function. It is recommended to
specify the comparison function in a GIN operator class that is meant for
just one data type, as looking up the btree operator class costs a few
cycles. However, polymorphic GIN operator classes (such
as <literal>array_ops</>) typically cannot specify a single comparison
function.
</para>
<para>
Optionally, an operator class for <acronym>GIN</acronym> can supply the
following method:
......@@ -900,11 +629,9 @@
<title>Examples</title>
<para>
The <productname>PostgreSQL</productname> source distribution includes
<acronym>GIN</acronym> operator classes for <type>tsvector</> and
for one-dimensional arrays of all internal types. Prefix searching in
<type>tsvector</> is implemented using the <acronym>GIN</> partial match
feature.
The core <productname>PostgreSQL</> distribution
includes the <acronym>GIN</acronym> operator classes previously shown in
<xref linkend="gin-builtin-opclasses-table">.
The following <filename>contrib</> modules also contain
<acronym>GIN</acronym> operator classes:
......
doc/src/sgml/indices.sgml
View file @ fdc9186f
......@@ -315,9 +315,8 @@ SELECT * FROM places ORDER BY location <-> point '(101,456)' LIMIT 10;
operators with which a GIN index can be used vary depending on the
indexing strategy.
As an example, the standard distribution of
<productname>PostgreSQL</productname> includes GIN operator classes
for one-dimensional arrays, which support indexed
queries using these operators:
<productname>PostgreSQL</productname> includes a GIN operator class
for arrays, which supports indexed queries using these operators:
<simplelist>
<member><literal>&lt;@</literal></member>
......
doc/src/sgml/ref/create_opclass.sgml
View file @ fdc9186f
......@@ -235,6 +235,11 @@ CREATE OPERATOR CLASS <replaceable class="parameter">name</replaceable> [ DEFAUL
(currently GiST, GIN and BRIN) allow it to be different. The
<literal>STORAGE</> clause must be omitted unless the index
method allows a different type to be used.
If the column <replaceable class="parameter">data_type</> is specified
as <type>anyarray</>, the <replaceable class="parameter">storage_type</>
can be declared as <type>anyelement</> to indicate that the index
entries are members of the element type belonging to the actual array
type that each particular index is created for.
</para>
</listitem>
</varlistentry>
......
doc/src/sgml/xindex.sgml
View file @ fdc9186f
......@@ -288,7 +288,7 @@
have a fixed set of strategies either. Instead the support routines of
each operator class interpret the strategy numbers according to the
operator class's definition. As an example, the strategy numbers used by
the built-in operator classes for arrays are shown in
the built-in operator class for arrays are shown in
<xref linkend="xindex-gin-array-strat-table">.
</para>
......
src/backend/access/gin/ginutil.c
View file @ fdc9186f
......@@ -22,7 +22,9 @@
#include "miscadmin.h"
#include "storage/indexfsm.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/index_selfuncs.h"
#include "utils/typcache.h"
/*
......@@ -105,9 +107,33 @@ initGinState(GinState *state, Relation index)
origTupdesc->attrs[i]->attcollation);
}
fmgr_info_copy(&(state->compareFn[i]),
index_getprocinfo(index, i + 1, GIN_COMPARE_PROC),
CurrentMemoryContext);
/*
* If the compare proc isn't specified in the opclass definition, look
* up the index key type's default btree comparator.
*/
if (index_getprocid(index, i + 1, GIN_COMPARE_PROC) != InvalidOid)
{
fmgr_info_copy(&(state->compareFn[i]),
index_getprocinfo(index, i + 1, GIN_COMPARE_PROC),
CurrentMemoryContext);
}
else
{
TypeCacheEntry *typentry;
typentry = lookup_type_cache(origTupdesc->attrs[i]->atttypid,
TYPECACHE_CMP_PROC_FINFO);
if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
errmsg("could not identify a comparison function for type %s",
format_type_be(origTupdesc->attrs[i]->atttypid))));
fmgr_info_copy(&(state->compareFn[i]),
&(typentry->cmp_proc_finfo),
CurrentMemoryContext);
}
/* Opclass must always provide extract procs */
fmgr_info_copy(&(state->extractValueFn[i]),
index_getprocinfo(index, i + 1, GIN_EXTRACTVALUE_PROC),
CurrentMemoryContext);
......
src/backend/access/gin/ginvalidate.c
View file @ fdc9186f
......@@ -237,7 +237,7 @@ ginvalidate(Oid opclassoid)
if (opclassgroup &&
(opclassgroup->functionset & (((uint64) 1) << i)) != 0)
continue; /* got it */
if (i == GIN_COMPARE_PARTIAL_PROC)
if (i == GIN_COMPARE_PROC || i == GIN_COMPARE_PARTIAL_PROC)
continue; /* optional method */
if (i == GIN_CONSISTENT_PROC || i == GIN_TRICONSISTENT_PROC)
continue; /* don't need both, see check below loop */
......
src/backend/catalog/index.c
View file @ fdc9186f
......@@ -437,11 +437,28 @@ ConstructTupleDescriptor(Relation heapRelation,
keyType = opclassTup->opckeytype;
else
keyType = amroutine->amkeytype;
/*
* If keytype is specified as ANYELEMENT, and opcintype is ANYARRAY,
* then the attribute type must be an array (else it'd not have
* matched this opclass); use its element type.
*/
if (keyType == ANYELEMENTOID && opclassTup->opcintype == ANYARRAYOID)
{
keyType = get_base_element_type(to->atttypid);
if (!OidIsValid(keyType))
elog(ERROR, "could not get element type of array type %u",
to->atttypid);
}
ReleaseSysCache(tuple);
/*
* If a key type different from the heap value is specified, update
* the type-related fields in the index tupdesc.
*/
if (OidIsValid(keyType) && keyType != to->atttypid)
{
/* index value and heap value have different types */
tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(keyType));
if (!HeapTupleIsValid(tuple))
elog(ERROR, "cache lookup failed for type %u", keyType);
......
src/include/catalog/catversion.h
View file @ fdc9186f
......@@ -53,6 +53,6 @@
*/
/* yyyymmddN */
#define CATALOG_VERSION_NO 201609131
#define CATALOG_VERSION_NO 201609261
#endif
src/include/catalog/pg_amop.h
View file @ fdc9186f
......@@ -673,8 +673,7 @@ DATA(insert ( 2595 718 718 14 s 2864 783 0 ));
DATA(insert ( 2595 718 600 15 o 3291 783 1970 ));
/*
* gin array_ops (these anyarray operators are used with all the opclasses
* of the family)
* gin array_ops
*/
DATA(insert ( 2745 2277 2277 1 s 2750 2742 0 ));
DATA(insert ( 2745 2277 2277 2 s 2751 2742 0 ));
......
src/include/catalog/pg_amproc.h
View file @ fdc9186f
......@@ -255,156 +255,10 @@ DATA(insert ( 3550 869 869 9 3573 ));
/* gin */
DATA(insert ( 2745 1007 1007 1 351 ));
DATA(insert ( 2745 1007 1007 2 2743 ));
DATA(insert ( 2745 1007 1007 3 2774 ));
DATA(insert ( 2745 1007 1007 4 2744 ));
DATA(insert ( 2745 1007 1007 6 3920 ));
DATA(insert ( 2745 1009 1009 1 360 ));
DATA(insert ( 2745 1009 1009 2 2743 ));
DATA(insert ( 2745 1009 1009 3 2774 ));
DATA(insert ( 2745 1009 1009 4 2744 ));
DATA(insert ( 2745 1009 1009 6 3920 ));
DATA(insert ( 2745 1015 1015 1 360 ));
DATA(insert ( 2745 1015 1015 2 2743 ));
DATA(insert ( 2745 1015 1015 3 2774 ));
DATA(insert ( 2745 1015 1015 4 2744 ));
DATA(insert ( 2745 1015 1015 6 3920 ));
DATA(insert ( 2745 1023 1023 1 357 ));
DATA(insert ( 2745 1023 1023 2 2743 ));
DATA(insert ( 2745 1023 1023 3 2774 ));
DATA(insert ( 2745 1023 1023 4 2744 ));
DATA(insert ( 2745 1023 1023 6 3920 ));
DATA(insert ( 2745 1561 1561 1 1596 ));
DATA(insert ( 2745 1561 1561 2 2743 ));
DATA(insert ( 2745 1561 1561 3 2774 ));
DATA(insert ( 2745 1561 1561 4 2744 ));
DATA(insert ( 2745 1561 1561 6 3920 ));
DATA(insert ( 2745 1000 1000 1 1693 ));
DATA(insert ( 2745 1000 1000 2 2743 ));
DATA(insert ( 2745 1000 1000 3 2774 ));
DATA(insert ( 2745 1000 1000 4 2744 ));
DATA(insert ( 2745 1000 1000 6 3920 ));
DATA(insert ( 2745 1014 1014 1 1078 ));
DATA(insert ( 2745 1014 1014 2 2743 ));
DATA(insert ( 2745 1014 1014 3 2774 ));
DATA(insert ( 2745 1014 1014 4 2744 ));
DATA(insert ( 2745 1014 1014 6 3920 ));
DATA(insert ( 2745 1001 1001 1 1954 ));
DATA(insert ( 2745 1001 1001 2 2743 ));
DATA(insert ( 2745 1001 1001 3 2774 ));
DATA(insert ( 2745 1001 1001 4 2744 ));
DATA(insert ( 2745 1001 1001 6 3920 ));
DATA(insert ( 2745 1002 1002 1 358 ));
DATA(insert ( 2745 1002 1002 2 2743 ));
DATA(insert ( 2745 1002 1002 3 2774 ));
DATA(insert ( 2745 1002 1002 4 2744 ));
DATA(insert ( 2745 1002 1002 6 3920 ));
DATA(insert ( 2745 1182 1182 1 1092 ));
DATA(insert ( 2745 1182 1182 2 2743 ));
DATA(insert ( 2745 1182 1182 3 2774 ));
DATA(insert ( 2745 1182 1182 4 2744 ));
DATA(insert ( 2745 1182 1182 6 3920 ));
DATA(insert ( 2745 1021 1021 1 354 ));
DATA(insert ( 2745 1021 1021 2 2743 ));
DATA(insert ( 2745 1021 1021 3 2774 ));
DATA(insert ( 2745 1021 1021 4 2744 ));
DATA(insert ( 2745 1021 1021 6 3920 ));
DATA(insert ( 2745 1022 1022 1 355 ));
DATA(insert ( 2745 1022 1022 2 2743 ));
DATA(insert ( 2745 1022 1022 3 2774 ));
DATA(insert ( 2745 1022 1022 4 2744 ));
DATA(insert ( 2745 1022 1022 6 3920 ));
DATA(insert ( 2745 1041 1041 1 926 ));
DATA(insert ( 2745 1041 1041 2 2743 ));
DATA(insert ( 2745 1041 1041 3 2774 ));
DATA(insert ( 2745 1041 1041 4 2744 ));
DATA(insert ( 2745 1041 1041 6 3920 ));
DATA(insert ( 2745 651 651 1 926 ));
DATA(insert ( 2745 651 651 2 2743 ));
DATA(insert ( 2745 651 651 3 2774 ));
DATA(insert ( 2745 651 651 4 2744 ));
DATA(insert ( 2745 651 651 6 3920 ));
DATA(insert ( 2745 1005 1005 1 350 ));
DATA(insert ( 2745 1005 1005 2 2743 ));
DATA(insert ( 2745 1005 1005 3 2774 ));
DATA(insert ( 2745 1005 1005 4 2744 ));
DATA(insert ( 2745 1005 1005 6 3920 ));
DATA(insert ( 2745 1016 1016 1 842 ));
DATA(insert ( 2745 1016 1016 2 2743 ));
DATA(insert ( 2745 1016 1016 3 2774 ));
DATA(insert ( 2745 1016 1016 4 2744 ));
DATA(insert ( 2745 1016 1016 6 3920 ));
DATA(insert ( 2745 1187 1187 1 1315 ));
DATA(insert ( 2745 1187 1187 2 2743 ));
DATA(insert ( 2745 1187 1187 3 2774 ));
DATA(insert ( 2745 1187 1187 4 2744 ));
DATA(insert ( 2745 1187 1187 6 3920 ));
DATA(insert ( 2745 1040 1040 1 836 ));
DATA(insert ( 2745 1040 1040 2 2743 ));
DATA(insert ( 2745 1040 1040 3 2774 ));
DATA(insert ( 2745 1040 1040 4 2744 ));
DATA(insert ( 2745 1040 1040 6 3920 ));
DATA(insert ( 2745 1003 1003 1 359 ));
DATA(insert ( 2745 1003 1003 2 2743 ));
DATA(insert ( 2745 1003 1003 3 2774 ));
DATA(insert ( 2745 1003 1003 4 2744 ));
DATA(insert ( 2745 1003 1003 6 3920 ));
DATA(insert ( 2745 1231 1231 1 1769 ));
DATA(insert ( 2745 1231 1231 2 2743 ));
DATA(insert ( 2745 1231 1231 3 2774 ));
DATA(insert ( 2745 1231 1231 4 2744 ));
DATA(insert ( 2745 1231 1231 6 3920 ));
DATA(insert ( 2745 1028 1028 1 356 ));
DATA(insert ( 2745 1028 1028 2 2743 ));
DATA(insert ( 2745 1028 1028 3 2774 ));
DATA(insert ( 2745 1028 1028 4 2744 ));
DATA(insert ( 2745 1028 1028 6 3920 ));
DATA(insert ( 2745 1013 1013 1 404 ));
DATA(insert ( 2745 1013 1013 2 2743 ));
DATA(insert ( 2745 1013 1013 3 2774 ));
DATA(insert ( 2745 1013 1013 4 2744 ));
DATA(insert ( 2745 1013 1013 6 3920 ));
DATA(insert ( 2745 1183 1183 1 1107 ));
DATA(insert ( 2745 1183 1183 2 2743 ));
DATA(insert ( 2745 1183 1183 3 2774 ));
DATA(insert ( 2745 1183 1183 4 2744 ));
DATA(insert ( 2745 1183 1183 6 3920 ));
DATA(insert ( 2745 1185 1185 1 1314 ));
DATA(insert ( 2745 1185 1185 2 2743 ));
DATA(insert ( 2745 1185 1185 3 2774 ));
DATA(insert ( 2745 1185 1185 4 2744 ));
DATA(insert ( 2745 1185 1185 6 3920 ));
DATA(insert ( 2745 1270 1270 1 1358 ));
DATA(insert ( 2745 1270 1270 2 2743 ));
DATA(insert ( 2745 1270 1270 3 2774 ));
DATA(insert ( 2745 1270 1270 4 2744 ));
DATA(insert ( 2745 1270 1270 6 3920 ));
DATA(insert ( 2745 1563 1563 1 1672 ));
DATA(insert ( 2745 1563 1563 2 2743 ));
DATA(insert ( 2745 1563 1563 3 2774 ));
DATA(insert ( 2745 1563 1563 4 2744 ));
DATA(insert ( 2745 1563 1563 6 3920 ));
DATA(insert ( 2745 1115 1115 1 2045 ));
DATA(insert ( 2745 1115 1115 2 2743 ));
DATA(insert ( 2745 1115 1115 3 2774 ));
DATA(insert ( 2745 1115 1115 4 2744 ));
DATA(insert ( 2745 1115 1115 6 3920 ));
DATA(insert ( 2745 791 791 1 377 ));
DATA(insert ( 2745 791 791 2 2743 ));
DATA(insert ( 2745 791 791 3 2774 ));
DATA(insert ( 2745 791 791 4 2744 ));
DATA(insert ( 2745 791 791 6 3920 ));
DATA(insert ( 2745 1024 1024 1 380 ));
DATA(insert ( 2745 1024 1024 2 2743 ));
DATA(insert ( 2745 1024 1024 3 2774 ));
DATA(insert ( 2745 1024 1024 4 2744 ));
DATA(insert ( 2745 1024 1024 6 3920 ));
DATA(insert ( 2745 1025 1025 1 381 ));
DATA(insert ( 2745 1025 1025 2 2743 ));
DATA(insert ( 2745 1025 1025 3 2774 ));
DATA(insert ( 2745 1025 1025 4 2744 ));
DATA(insert ( 2745 1025 1025 6 3920 ));
DATA(insert ( 2745 2277 2277 2 2743 ));
DATA(insert ( 2745 2277 2277 3 2774 ));
DATA(insert ( 2745 2277 2277 4 2744 ));
DATA(insert ( 2745 2277 2277 6 3920 ));
DATA(insert ( 3659 3614 3614 1 3724 ));
DATA(insert ( 3659 3614 3614 2 3656 ));
DATA(insert ( 3659 3614 3614 3 3657 ));
......
src/include/catalog/pg_opclass.h
View file @ fdc9186f
......@@ -184,36 +184,7 @@ DATA(insert ( 783 box_ops PGNSP PGUID 2593 603 t 0 ));
DATA(insert ( 783 point_ops PGNSP PGUID 1029 600 t 603 ));
DATA(insert ( 783 poly_ops PGNSP PGUID 2594 604 t 603 ));
DATA(insert ( 783 circle_ops PGNSP PGUID 2595 718 t 603 ));
DATA(insert ( 2742 _int4_ops PGNSP PGUID 2745 1007 t 23 ));
DATA(insert ( 2742 _text_ops PGNSP PGUID 2745 1009 t 25 ));
DATA(insert ( 2742 _abstime_ops PGNSP PGUID 2745 1023 t 702 ));
DATA(insert ( 2742 _bit_ops PGNSP PGUID 2745 1561 t 1560 ));
DATA(insert ( 2742 _bool_ops PGNSP PGUID 2745 1000 t 16 ));
DATA(insert ( 2742 _bpchar_ops PGNSP PGUID 2745 1014 t 1042 ));
DATA(insert ( 2742 _bytea_ops PGNSP PGUID 2745 1001 t 17 ));
DATA(insert ( 2742 _char_ops PGNSP PGUID 2745 1002 t 18 ));
DATA(insert ( 2742 _cidr_ops PGNSP PGUID 2745 651 t 650 ));
DATA(insert ( 2742 _date_ops PGNSP PGUID 2745 1182 t 1082 ));
DATA(insert ( 2742 _float4_ops PGNSP PGUID 2745 1021 t 700 ));
DATA(insert ( 2742 _float8_ops PGNSP PGUID 2745 1022 t 701 ));
DATA(insert ( 2742 _inet_ops PGNSP PGUID 2745 1041 t 869 ));
DATA(insert ( 2742 _int2_ops PGNSP PGUID 2745 1005 t 21 ));
DATA(insert ( 2742 _int8_ops PGNSP PGUID 2745 1016 t 20 ));
DATA(insert ( 2742 _interval_ops PGNSP PGUID 2745 1187 t 1186 ));
DATA(insert ( 2742 _macaddr_ops PGNSP PGUID 2745 1040 t 829 ));
DATA(insert ( 2742 _name_ops PGNSP PGUID 2745 1003 t 19 ));
DATA(insert ( 2742 _numeric_ops PGNSP PGUID 2745 1231 t 1700 ));
DATA(insert ( 2742 _oid_ops PGNSP PGUID 2745 1028 t 26 ));
DATA(insert ( 2742 _oidvector_ops PGNSP PGUID 2745 1013 t 30 ));
DATA(insert ( 2742 _time_ops PGNSP PGUID 2745 1183 t 1083 ));
DATA(insert ( 2742 _timestamptz_ops PGNSP PGUID 2745 1185 t 1184 ));
DATA(insert ( 2742 _timetz_ops PGNSP PGUID 2745 1270 t 1266 ));
DATA(insert ( 2742 _varbit_ops PGNSP PGUID 2745 1563 t 1562 ));
DATA(insert ( 2742 _varchar_ops PGNSP PGUID 2745 1015 t 1043 ));
DATA(insert ( 2742 _timestamp_ops PGNSP PGUID 2745 1115 t 1114 ));
DATA(insert ( 2742 _money_ops PGNSP PGUID 2745 791 t 790 ));
DATA(insert ( 2742 _reltime_ops PGNSP PGUID 2745 1024 t 703 ));
DATA(insert ( 2742 _tinterval_ops PGNSP PGUID 2745 1025 t 704 ));
DATA(insert ( 2742 array_ops PGNSP PGUID 2745 2277 t 2283 ));
DATA(insert ( 403 uuid_ops PGNSP PGUID 2968 2950 t 0 ));
DATA(insert ( 405 uuid_ops PGNSP PGUID 2969 2950 t 0 ));
DATA(insert ( 403 pg_lsn_ops PGNSP PGUID 3253 3220 t 0 ));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment