On 27.11.24 13:57, Peter Eisentraut wrote:
I think, however, that we should rename RowCompareType. Otherwise, it's
just going to be confusing forevermore. I suggest to rename it simply
to CompareType.
I'm going to try to code up the gist support on top of this patch set to
make sure that it will fit well. I'll report back.
Here is a patch set in that direction. It renames RowCompareType to
CompareType and updates the surrounding commentary a bit. And then I'm
changing the gist strategy mapping to use the CompareType values instead
of the RT* strategy numbers. Seeing this now, I like this a lot better
than what we have now, because it makes it clearer in the API and the
code what is a real strategy number and what's a different kind of
thing. (This isn't entirely the above-mentioned integration of the gist
support into your patch set yet, but it's a meaningful part of it.)
From 9da99d3958cddb86ad98ea88687a13f08a12cf16 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <pe...@eisentraut.org>
Date: Wed, 4 Dec 2024 14:03:24 +0100
Subject: [PATCH v19.1 1/2] Rename RowCompareType to CompareType
RowCompareType served as a way to describe the fundamental meaning of
an operator, notionally independent of an operator class (although so
far this was only really supported for btrees). Its original purpose
was for use inside RowCompareExpr, and it has also found some small
use outside, such as for get_op_btree_interpretation().
We want to expand this now, as a more general way to describe operator
semantics for other index access methods, including gist (to improve
GistTranslateStratnum()) and others not written yet. To avoid future
confusion, we rename the type to CompareType and the symbols from
ROWCOMPARE_XXX to COMPARE_XXX to reflect their more general purpose.
---
src/backend/executor/execExpr.c | 2 +-
src/backend/executor/execExprInterp.c | 12 ++++----
src/backend/executor/nodeIndexscan.c | 4 +--
src/backend/jit/llvm/llvmjit_expr.c | 12 ++++----
src/backend/optimizer/path/indxpath.c | 2 +-
src/backend/optimizer/util/predtest.c | 2 +-
src/backend/parser/parse_expr.c | 12 ++++----
src/backend/utils/cache/lsyscache.c | 6 ++--
src/include/executor/execExpr.h | 2 +-
src/include/nodes/primnodes.h | 41 ++++++++++++++++++---------
src/tools/pgindent/typedefs.list | 2 +-
11 files changed, 55 insertions(+), 42 deletions(-)
diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
index e0eb96fd5ad..afa0f6b14a6 100644
--- a/src/backend/executor/execExpr.c
+++ b/src/backend/executor/execExpr.c
@@ -2102,7 +2102,7 @@ ExecInitExprRec(Expr *node, ExprState *state,
/* Finally, examine the last comparison result
*/
scratch.opcode = EEOP_ROWCOMPARE_FINAL;
- scratch.d.rowcompare_final.rctype =
rcexpr->rctype;
+ scratch.d.rowcompare_final.cmptype =
rcexpr->cmptype;
ExprEvalPushStep(state, &scratch);
/* adjust jump targets */
diff --git a/src/backend/executor/execExprInterp.c
b/src/backend/executor/execExprInterp.c
index bad7b195bfb..7ffb611ab8c 100644
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -1438,22 +1438,22 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext,
bool *isnull)
EEO_CASE(EEOP_ROWCOMPARE_FINAL)
{
int32 cmpresult =
DatumGetInt32(*op->resvalue);
- RowCompareType rctype = op->d.rowcompare_final.rctype;
+ CompareType cmptype = op->d.rowcompare_final.cmptype;
*op->resnull = false;
- switch (rctype)
+ switch (cmptype)
{
/* EQ and NE cases aren't allowed here
*/
- case ROWCOMPARE_LT:
+ case COMPARE_LT:
*op->resvalue = BoolGetDatum(cmpresult
< 0);
break;
- case ROWCOMPARE_LE:
+ case COMPARE_LE:
*op->resvalue = BoolGetDatum(cmpresult
<= 0);
break;
- case ROWCOMPARE_GE:
+ case COMPARE_GE:
*op->resvalue = BoolGetDatum(cmpresult
>= 0);
break;
- case ROWCOMPARE_GT:
+ case COMPARE_GT:
*op->resvalue = BoolGetDatum(cmpresult
> 0);
break;
default:
diff --git a/src/backend/executor/nodeIndexscan.c
b/src/backend/executor/nodeIndexscan.c
index 8000feff4c9..5377ce4ec30 100644
--- a/src/backend/executor/nodeIndexscan.c
+++ b/src/backend/executor/nodeIndexscan.c
@@ -1344,7 +1344,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation
index,
&op_lefttype,
&op_righttype);
- if (op_strategy != rc->rctype)
+ if (op_strategy != rc->cmptype)
elog(ERROR, "RowCompare index
qualification contains wrong operator");
opfuncid = get_opfamily_proc(opfamily,
@@ -1421,7 +1421,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation
index,
MemSet(this_scan_key, 0, sizeof(ScanKeyData));
this_scan_key->sk_flags = SK_ROW_HEADER;
this_scan_key->sk_attno = first_sub_key->sk_attno;
- this_scan_key->sk_strategy = rc->rctype;
+ this_scan_key->sk_strategy = rc->cmptype;
/* sk_subtype, sk_collation, sk_func not used in a
header */
this_scan_key->sk_argument =
PointerGetDatum(first_sub_key);
}
diff --git a/src/backend/jit/llvm/llvmjit_expr.c
b/src/backend/jit/llvm/llvmjit_expr.c
index c533f552540..88bef871413 100644
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -1770,7 +1770,7 @@ llvm_compile_expr(ExprState *state)
case EEOP_ROWCOMPARE_FINAL:
{
- RowCompareType rctype =
op->d.rowcompare_final.rctype;
+ CompareType cmptype =
op->d.rowcompare_final.cmptype;
LLVMValueRef v_cmpresult;
LLVMValueRef v_result;
@@ -1786,18 +1786,18 @@ llvm_compile_expr(ExprState *state)
l_load(b, TypeSizeT, v_resvaluep, ""),
LLVMInt32TypeInContext(lc), "");
- switch (rctype)
+ switch (cmptype)
{
- case ROWCOMPARE_LT:
+ case COMPARE_LT:
predicate = LLVMIntSLT;
break;
- case ROWCOMPARE_LE:
+ case COMPARE_LE:
predicate = LLVMIntSLE;
break;
- case ROWCOMPARE_GT:
+ case COMPARE_GT:
predicate = LLVMIntSGT;
break;
- case ROWCOMPARE_GE:
+ case COMPARE_GE:
predicate = LLVMIntSGE;
break;
default:
diff --git a/src/backend/optimizer/path/indxpath.c
b/src/backend/optimizer/path/indxpath.c
index 5d102a0d371..10f4c6a1f19 100644
--- a/src/backend/optimizer/path/indxpath.c
+++ b/src/backend/optimizer/path/indxpath.c
@@ -3675,7 +3675,7 @@ expand_indexqual_rowcompare(PlannerInfo *root,
{
RowCompareExpr *rc = makeNode(RowCompareExpr);
- rc->rctype = (RowCompareType) op_strategy;
+ rc->cmptype = (CompareType) op_strategy;
rc->opnos = new_ops;
rc->opfamilies = list_copy_head(clause->opfamilies,
matching_cols);
diff --git a/src/backend/optimizer/util/predtest.c
b/src/backend/optimizer/util/predtest.c
index 0a132610140..e967d831bf1 100644
--- a/src/backend/optimizer/util/predtest.c
+++ b/src/backend/optimizer/util/predtest.c
@@ -1664,7 +1664,7 @@ clause_is_strict_for(Node *clause, Node *subexpr, bool
allow_false)
#define BTEQ BTEqualStrategyNumber
#define BTGE BTGreaterEqualStrategyNumber
#define BTGT BTGreaterStrategyNumber
-#define BTNE ROWCOMPARE_NE
+#define BTNE COMPARE_NE
/* We use "none" for 0/false to make the tables align nicely */
#define none 0
diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index c2806297aa4..f31e9a4e879 100644
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -2807,7 +2807,7 @@ make_row_comparison_op(ParseState *pstate, List *opname,
List *largs, List *rargs, int
location)
{
RowCompareExpr *rcexpr;
- RowCompareType rctype;
+ CompareType cmptype;
List *opexprs;
List *opnos;
List *opfamilies;
@@ -2928,15 +2928,15 @@ make_row_comparison_op(ParseState *pstate, List *opname,
errhint("Row comparison operators must be
associated with btree operator families."),
parser_errposition(pstate, location)));
}
- rctype = (RowCompareType) i;
+ cmptype = (CompareType) i;
/*
* For = and <> cases, we just combine the pairwise operators with AND
or
* OR respectively.
*/
- if (rctype == ROWCOMPARE_EQ)
+ if (cmptype == COMPARE_EQ)
return (Node *) makeBoolExpr(AND_EXPR, opexprs, location);
- if (rctype == ROWCOMPARE_NE)
+ if (cmptype == COMPARE_NE)
return (Node *) makeBoolExpr(OR_EXPR, opexprs, location);
/*
@@ -2953,7 +2953,7 @@ make_row_comparison_op(ParseState *pstate, List *opname,
{
OpBtreeInterpretation *opinfo = lfirst(j);
- if (opinfo->strategy == rctype)
+ if (opinfo->strategy == cmptype)
{
opfamily = opinfo->opfamily_id;
break;
@@ -2989,7 +2989,7 @@ make_row_comparison_op(ParseState *pstate, List *opname,
}
rcexpr = makeNode(RowCompareExpr);
- rcexpr->rctype = rctype;
+ rcexpr->cmptype = cmptype;
rcexpr->opnos = opnos;
rcexpr->opfamilies = opfamilies;
rcexpr->inputcollids = NIL; /* assign_expr_collations will fix this */
diff --git a/src/backend/utils/cache/lsyscache.c
b/src/backend/utils/cache/lsyscache.c
index a85dc0d891f..af68dce0907 100644
--- a/src/backend/utils/cache/lsyscache.c
+++ b/src/backend/utils/cache/lsyscache.c
@@ -595,7 +595,7 @@ get_op_hash_functions(Oid opno,
*
* In addition to the normal btree operators, we consider a <> operator to be
* a "member" of an opfamily if its negator is an equality operator of the
- * opfamily. ROWCOMPARE_NE is returned as the strategy number for this case.
+ * opfamily. COMPARE_NE is returned as the strategy number for this case.
*/
List *
get_op_btree_interpretation(Oid opno)
@@ -666,11 +666,11 @@ get_op_btree_interpretation(Oid opno)
if (op_strategy != BTEqualStrategyNumber)
continue;
- /* OK, report it with "strategy" ROWCOMPARE_NE
*/
+ /* OK, report it with "strategy" COMPARE_NE */
thisresult = (OpBtreeInterpretation *)
palloc(sizeof(OpBtreeInterpretation));
thisresult->opfamily_id = op_form->amopfamily;
- thisresult->strategy = ROWCOMPARE_NE;
+ thisresult->strategy = COMPARE_NE;
thisresult->oplefttype = op_form->amoplefttype;
thisresult->oprighttype =
op_form->amoprighttype;
result = lappend(result, thisresult);
diff --git a/src/include/executor/execExpr.h b/src/include/executor/execExpr.h
index 56fb0d0adbe..42db1161da1 100644
--- a/src/include/executor/execExpr.h
+++ b/src/include/executor/execExpr.h
@@ -494,7 +494,7 @@ typedef struct ExprEvalStep
/* for EEOP_ROWCOMPARE_FINAL */
struct
{
- RowCompareType rctype;
+ CompareType cmptype;
} rowcompare_final;
/* for EEOP_MINMAX */
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index b0ef1952e8f..107eb36a340 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1435,6 +1435,31 @@ typedef struct RowExpr
ParseLoc location; /* token location, or -1 if
unknown */
} RowExpr;
+/*
+ * CompareType - fundamental semantics of certain operators
+ *
+ * These enum symbols represent the fundamental semantics of certain operators
+ * that the system needs to have some hardcoded knowledge about. (For
+ * example, RowCompareExpr needs to know which operators can be determined to
+ * act like =, <>, <, etc.) Index access methods map (some of) strategy
+ * numbers to these values so that the system can know about the meaning of
+ * (some of) the operators without needing hardcoded knowledge of index AM's
+ * strategy numbering.
+ *
+ * XXX Currently, this mapping is not fully developed and the values are
+ * chosen to match btree strategy numbers, which is not going to work very
+ * well for other access methods.
+ */
+typedef enum CompareType
+{
+ COMPARE_LT = 1, /* BTLessStrategyNumber */
+ COMPARE_LE = 2, /* BTLessEqualStrategyNumber */
+ COMPARE_EQ = 3, /* BTEqualStrategyNumber */
+ COMPARE_GE = 4, /* BTGreaterEqualStrategyNumber
*/
+ COMPARE_GT = 5, /* BTGreaterStrategyNumber */
+ COMPARE_NE = 6, /* no such btree strategy */
+} CompareType;
+
/*
* RowCompareExpr - row-wise comparison, such as (a, b) <= (1, 2)
*
@@ -1446,26 +1471,14 @@ typedef struct RowExpr
*
* A RowCompareExpr node is only generated for the < <= > >= cases;
* the = and <> cases are translated to simple AND or OR combinations
- * of the pairwise comparisons. However, we include = and <> in the
- * RowCompareType enum for the convenience of parser logic.
+ * of the pairwise comparisons.
*/
-typedef enum RowCompareType
-{
- /* Values of this enum are chosen to match btree strategy numbers */
- ROWCOMPARE_LT = 1, /* BTLessStrategyNumber */
- ROWCOMPARE_LE = 2, /* BTLessEqualStrategyNumber */
- ROWCOMPARE_EQ = 3, /* BTEqualStrategyNumber */
- ROWCOMPARE_GE = 4, /* BTGreaterEqualStrategyNumber
*/
- ROWCOMPARE_GT = 5, /* BTGreaterStrategyNumber */
- ROWCOMPARE_NE = 6, /* no such btree strategy */
-} RowCompareType;
-
typedef struct RowCompareExpr
{
Expr xpr;
/* LT LE GE or GT, never EQ or NE */
- RowCompareType rctype;
+ CompareType cmptype;
/* OID list of pairwise comparison ops */
List *opnos pg_node_attr(query_jumble_ignore);
/* OID list of containing operator families */
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 2d4c870423a..4100e634964 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -455,6 +455,7 @@ CommitTimestampShared
CommonEntry
CommonTableExpr
CompareScalarsContext
+CompareType
CompiledExprState
CompositeIOData
CompositeTypeStmt
@@ -2487,7 +2488,6 @@ RoleSpecType
RoleStmtType
RollupData
RowCompareExpr
-RowCompareType
RowExpr
RowIdentityVarInfo
RowMarkClause
base-commit: 7727049e8f663344d4d0457e1d9ec048d626f3d9
--
2.47.1
From 9509de62880094562eb234e4bdecbaed5062ff91 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <pe...@eisentraut.org>
Date: Wed, 4 Dec 2024 15:31:18 +0100
Subject: [PATCH v19.1 2/2] Change gist stratnum function to use CompareType
This changes commit 7406ab623fe in that the gist strategy number
mapping support function is changed to use the CompareType enum as
input, instead of the "well-known" RT*StrategyNumber strategy numbers.
This is a bit cleaner, since you are not dealing with two sets of
strategy numbers. Also, this will enable us to subsume this system
into a more general system of using CompareType to define operator
semantics across index methods.
---
contrib/btree_gist/btree_gist--1.7--1.8.sql | 54 ++++++++++----------
contrib/btree_gist/btree_gist.c | 15 +++---
contrib/btree_gist/expected/stratnum.out | 4 +-
contrib/btree_gist/sql/stratnum.sql | 4 +-
doc/src/sgml/gist.sgml | 24 ++++-----
doc/src/sgml/xindex.sgml | 2 +-
src/backend/access/gist/gistutil.c | 35 +++++++++----
src/backend/access/gist/gistvalidate.c | 2 +-
src/backend/catalog/pg_constraint.c | 20 ++++----
src/backend/commands/indexcmds.c | 50 +++++++++---------
src/backend/commands/tablecmds.c | 10 ++--
src/include/access/gist.h | 3 +-
src/include/catalog/pg_amproc.dat | 12 ++---
src/include/catalog/pg_proc.dat | 6 +--
src/include/commands/defrem.h | 4 +-
src/include/nodes/primnodes.h | 4 +-
src/test/regress/expected/misc_functions.out | 16 +++---
src/test/regress/sql/misc_functions.sql | 4 +-
18 files changed, 144 insertions(+), 125 deletions(-)
diff --git a/contrib/btree_gist/btree_gist--1.7--1.8.sql
b/contrib/btree_gist/btree_gist--1.7--1.8.sql
index 307bfe574b0..c702426deab 100644
--- a/contrib/btree_gist/btree_gist--1.7--1.8.sql
+++ b/contrib/btree_gist/btree_gist--1.7--1.8.sql
@@ -3,85 +3,85 @@
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.8'" to load this file. \quit
-CREATE FUNCTION gist_stratnum_btree(smallint)
+CREATE FUNCTION gist_stratnum_btree(int)
RETURNS smallint
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT;
ALTER OPERATOR FAMILY gist_oid_ops USING gist ADD
- FUNCTION 12 (oid, oid) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (oid, oid) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_int2_ops USING gist ADD
- FUNCTION 12 (int2, int2) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (int2, int2) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_int4_ops USING gist ADD
- FUNCTION 12 (int4, int4) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (int4, int4) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_int8_ops USING gist ADD
- FUNCTION 12 (int8, int8) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (int8, int8) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_float4_ops USING gist ADD
- FUNCTION 12 (float4, float4) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (float4, float4) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_float8_ops USING gist ADD
- FUNCTION 12 (float8, float8) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (float8, float8) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_timestamp_ops USING gist ADD
- FUNCTION 12 (timestamp, timestamp) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (timestamp, timestamp) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_timestamptz_ops USING gist ADD
- FUNCTION 12 (timestamptz, timestamptz) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (timestamptz, timestamptz) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_time_ops USING gist ADD
- FUNCTION 12 (time, time) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (time, time) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_date_ops USING gist ADD
- FUNCTION 12 (date, date) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (date, date) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_interval_ops USING gist ADD
- FUNCTION 12 (interval, interval) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (interval, interval) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_cash_ops USING gist ADD
- FUNCTION 12 (money, money) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (money, money) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_macaddr_ops USING gist ADD
- FUNCTION 12 (macaddr, macaddr) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (macaddr, macaddr) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_text_ops USING gist ADD
- FUNCTION 12 (text, text) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (text, text) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_bpchar_ops USING gist ADD
- FUNCTION 12 (bpchar, bpchar) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (bpchar, bpchar) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_bytea_ops USING gist ADD
- FUNCTION 12 (bytea, bytea) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (bytea, bytea) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_numeric_ops USING gist ADD
- FUNCTION 12 (numeric, numeric) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (numeric, numeric) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_bit_ops USING gist ADD
- FUNCTION 12 (bit, bit) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (bit, bit) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_vbit_ops USING gist ADD
- FUNCTION 12 (varbit, varbit) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (varbit, varbit) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_inet_ops USING gist ADD
- FUNCTION 12 (inet, inet) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (inet, inet) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_cidr_ops USING gist ADD
- FUNCTION 12 (cidr, cidr) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (cidr, cidr) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_timetz_ops USING gist ADD
- FUNCTION 12 (timetz, timetz) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (timetz, timetz) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_uuid_ops USING gist ADD
- FUNCTION 12 (uuid, uuid) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (uuid, uuid) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_macaddr8_ops USING gist ADD
- FUNCTION 12 (macaddr8, macaddr8) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (macaddr8, macaddr8) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_enum_ops USING gist ADD
- FUNCTION 12 (anyenum, anyenum) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (anyenum, anyenum) gist_stratnum_btree (int) ;
ALTER OPERATOR FAMILY gist_bool_ops USING gist ADD
- FUNCTION 12 (bool, bool) gist_stratnum_btree (int2) ;
+ FUNCTION 12 (bool, bool) gist_stratnum_btree (int) ;
diff --git a/contrib/btree_gist/btree_gist.c b/contrib/btree_gist/btree_gist.c
index 5fd4cce27d0..fc6c7091795 100644
--- a/contrib/btree_gist/btree_gist.c
+++ b/contrib/btree_gist/btree_gist.c
@@ -4,6 +4,7 @@
#include "postgres.h"
#include "access/stratnum.h"
+#include "nodes/primnodes.h"
#include "utils/builtins.h"
PG_MODULE_MAGIC;
@@ -60,19 +61,19 @@ gbt_decompress(PG_FUNCTION_ARGS)
Datum
gist_stratnum_btree(PG_FUNCTION_ARGS)
{
- StrategyNumber strat = PG_GETARG_UINT16(0);
+ CompareType cmptype = PG_GETARG_INT32(0);
- switch (strat)
+ switch (cmptype)
{
- case RTEqualStrategyNumber:
+ case COMPARE_EQ:
PG_RETURN_UINT16(BTEqualStrategyNumber);
- case RTLessStrategyNumber:
+ case COMPARE_LT:
PG_RETURN_UINT16(BTLessStrategyNumber);
- case RTLessEqualStrategyNumber:
+ case COMPARE_LE:
PG_RETURN_UINT16(BTLessEqualStrategyNumber);
- case RTGreaterStrategyNumber:
+ case COMPARE_GT:
PG_RETURN_UINT16(BTGreaterStrategyNumber);
- case RTGreaterEqualStrategyNumber:
+ case COMPARE_GE:
PG_RETURN_UINT16(BTGreaterEqualStrategyNumber);
default:
PG_RETURN_UINT16(InvalidStrategy);
diff --git a/contrib/btree_gist/expected/stratnum.out
b/contrib/btree_gist/expected/stratnum.out
index 9d80c6590d9..dd0edaf4a20 100644
--- a/contrib/btree_gist/expected/stratnum.out
+++ b/contrib/btree_gist/expected/stratnum.out
@@ -1,11 +1,11 @@
-- test stratnum support func
-SELECT gist_stratnum_btree(3::smallint);
+SELECT gist_stratnum_btree(7);
gist_stratnum_btree
---------------------
0
(1 row)
-SELECT gist_stratnum_btree(18::smallint);
+SELECT gist_stratnum_btree(3);
gist_stratnum_btree
---------------------
3
diff --git a/contrib/btree_gist/sql/stratnum.sql
b/contrib/btree_gist/sql/stratnum.sql
index f58cdbe93da..75adddad849 100644
--- a/contrib/btree_gist/sql/stratnum.sql
+++ b/contrib/btree_gist/sql/stratnum.sql
@@ -1,3 +1,3 @@
-- test stratnum support func
-SELECT gist_stratnum_btree(3::smallint);
-SELECT gist_stratnum_btree(18::smallint);
+SELECT gist_stratnum_btree(7);
+SELECT gist_stratnum_btree(3);
diff --git a/doc/src/sgml/gist.sgml b/doc/src/sgml/gist.sgml
index 638d912dc2d..99098ab2522 100644
--- a/doc/src/sgml/gist.sgml
+++ b/doc/src/sgml/gist.sgml
@@ -290,8 +290,8 @@ <title>Extensibility</title>
The optional eleventh method <function>sortsupport</function> is used to
speed up building a <acronym>GiST</acronym> index.
The optional twelfth method <function>stratnum</function> is used to
- translate well-known <literal>RT*StrategyNumber</literal>s (from
- <filename>src/include/access/stratnum.h</filename>) into strategy numbers
+ translate compare types (from
+ <filename>src/include/nodes/primnodes.h</filename>) into strategy numbers
used by the operator class. This lets the core code look up operators for
temporal constraint indexes.
</para>
@@ -1173,8 +1173,8 @@ <title>Extensibility</title>
<term><function>stratnum</function></term>
<listitem>
<para>
- Given an <literal>RT*StrategyNumber</literal> value from
- <filename>src/include/access/stratnum.h</filename>, returns a strategy
+ Given a <literal>CompareType</literal> value from
+ <filename>src/include/nodes/primnodes.h</filename>, returns a strategy
number used by this operator class for matching functionality. The
function should return <literal>InvalidStrategy</literal> if the
operator class has no matching strategy.
@@ -1184,7 +1184,7 @@ <title>Extensibility</title>
This is used for temporal index constraints (i.e., <literal>PRIMARY
KEY</literal> and <literal>UNIQUE</literal>). If the operator class
provides this function and it returns results for
- <literal>RTEqualStrategyNumber</literal>, it can be used in the
+ <literal>COMPARE_EQ</literal>, it can be used in the
non-<literal>WITHOUT OVERLAPS</literal> part(s) of an index constraint.
</para>
@@ -1194,7 +1194,7 @@ <title>Extensibility</title>
<programlisting>
CREATE OR REPLACE FUNCTION my_stratnum(integer)
-RETURNS integer
+RETURNS smallint
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;
</programlisting>
@@ -1209,12 +1209,12 @@ <title>Extensibility</title>
Datum
my_stratnum(PG_FUNCTION_ARGS)
{
- StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(1);
+ CompareType cmptype = PG_GETARG_INT32(0);
StrategyNumber ret = InvalidStrategy;
- switch (strategy)
+ switch (cmptype)
{
- case RTEqualStrategyNumber:
+ case COMPARE_EQ:
ret = BTEqualStrategyNumber;
}
@@ -1226,9 +1226,9 @@ <title>Extensibility</title>
<para>
One translation function is provided by
<productname>PostgreSQL</productname>:
- <literal>gist_stratnum_identity</literal> is for operator classes that
- already use the <literal>RT*StrategyNumber</literal> constants. It
- returns whatever is passed to it. The <literal>btree_gist</literal>
+ <literal>gist_stratnum_common</literal> is for operator classes that
+ use the <literal>RT*StrategyNumber</literal> constants.
+ The <literal>btree_gist</literal>
extension defines a second translation function,
<literal>gist_stratnum_btree</literal>, for operator classes that use
the <literal>BT*StrategyNumber</literal> constants.
diff --git a/doc/src/sgml/xindex.sgml b/doc/src/sgml/xindex.sgml
index 3a19dab15e0..05361962495 100644
--- a/doc/src/sgml/xindex.sgml
+++ b/doc/src/sgml/xindex.sgml
@@ -592,7 +592,7 @@ <title>GiST Support Functions</title>
</row>
<row>
<entry><function>stratnum</function></entry>
- <entry>translate well-known strategy numbers to ones
+ <entry>translate compare types to strategy numbers
used by the operator class (optional)</entry>
<entry>12</entry>
</row>
diff --git a/src/backend/access/gist/gistutil.c
b/src/backend/access/gist/gistutil.c
index d2d0b36d4ea..bde541a6251 100644
--- a/src/backend/access/gist/gistutil.c
+++ b/src/backend/access/gist/gistutil.c
@@ -1058,27 +1058,44 @@ gistGetFakeLSN(Relation rel)
}
/*
- * Returns the same number that was received.
- *
- * This is for GiST opclasses that use the RT*StrategyNumber constants.
+ * This is a stratnum support function for GiST opclasses that use the
+ * RT*StrategyNumber constants.
*/
Datum
-gist_stratnum_identity(PG_FUNCTION_ARGS)
+gist_stratnum_common(PG_FUNCTION_ARGS)
{
- StrategyNumber strat = PG_GETARG_UINT16(0);
+ CompareType cmptype = PG_GETARG_INT32(0);
- PG_RETURN_UINT16(strat);
+ switch (cmptype)
+ {
+ case COMPARE_EQ:
+ PG_RETURN_UINT16(RTEqualStrategyNumber);
+ case COMPARE_LT:
+ PG_RETURN_UINT16(RTLessStrategyNumber);
+ case COMPARE_LE:
+ PG_RETURN_UINT16(RTLessEqualStrategyNumber);
+ case COMPARE_GT:
+ PG_RETURN_UINT16(RTGreaterStrategyNumber);
+ case COMPARE_GE:
+ PG_RETURN_UINT16(RTGreaterEqualStrategyNumber);
+ case COMPARE_OVERLAP:
+ PG_RETURN_UINT16(RTOverlapStrategyNumber);
+ case COMPARE_CONTAINED_BY:
+ PG_RETURN_UINT16(RTContainedByStrategyNumber);
+ default:
+ PG_RETURN_UINT16(InvalidStrategy);
+ }
}
/*
- * Returns the opclass's private stratnum used for the given strategy.
+ * Returns the opclass's private stratnum used for the given compare type.
*
* Calls the opclass's GIST_STRATNUM_PROC support function, if any,
* and returns the result.
* Returns InvalidStrategy if the function is not defined.
*/
StrategyNumber
-GistTranslateStratnum(Oid opclass, StrategyNumber strat)
+GistTranslateStratnum(Oid opclass, CompareType cmptype)
{
Oid opfamily;
Oid opcintype;
@@ -1095,6 +1112,6 @@ GistTranslateStratnum(Oid opclass, StrategyNumber strat)
return InvalidStrategy;
/* Ask the translation function */
- result = OidFunctionCall1Coll(funcid, InvalidOid,
UInt16GetDatum(strat));
+ result = OidFunctionCall1Coll(funcid, InvalidOid,
Int32GetDatum(cmptype));
return DatumGetUInt16(result);
}
diff --git a/src/backend/access/gist/gistvalidate.c
b/src/backend/access/gist/gistvalidate.c
index 0901543a60a..7d51fc167d6 100644
--- a/src/backend/access/gist/gistvalidate.c
+++ b/src/backend/access/gist/gistvalidate.c
@@ -148,7 +148,7 @@ gistvalidate(Oid opclassoid)
break;
case GIST_STRATNUM_PROC:
ok = check_amproc_signature(procform->amproc,
INT2OID, true,
-
1, 1, INT2OID);
+
1, 1, INT4OID);
break;
default:
ereport(INFO,
diff --git a/src/backend/catalog/pg_constraint.c
b/src/backend/catalog/pg_constraint.c
index 9c05a98d28c..4a076e2874e 100644
--- a/src/backend/catalog/pg_constraint.c
+++ b/src/backend/catalog/pg_constraint.c
@@ -1638,22 +1638,22 @@ FindFKPeriodOpers(Oid opclass,
* of the old value, then we can treat the attribute as if it didn't
* change, and skip the RI check.
*/
- strat = RTContainedByStrategyNumber;
- GetOperatorFromWellKnownStrategy(opclass,
-
InvalidOid,
-
containedbyoperoid,
-
&strat);
+ GetOperatorFromCompareType(opclass,
+ InvalidOid,
+ COMPARE_CONTAINED_BY,
+ containedbyoperoid,
+ &strat);
/*
* Now look up the ContainedBy operator. Its left arg must be the type
of
* the column (or rather of the opclass). Its right arg must match the
* return type of the support proc.
*/
- strat = RTContainedByStrategyNumber;
- GetOperatorFromWellKnownStrategy(opclass,
-
ANYMULTIRANGEOID,
-
aggedcontainedbyoperoid,
-
&strat);
+ GetOperatorFromCompareType(opclass,
+ ANYMULTIRANGEOID,
+ COMPARE_CONTAINED_BY,
+
aggedcontainedbyoperoid,
+ &strat);
}
/*
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index 4049ce1a10f..9c1a159754c 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -2178,15 +2178,15 @@ ComputeIndexAttrs(IndexInfo *indexInfo,
}
else if (iswithoutoverlaps)
{
+ CompareType cmptype;
StrategyNumber strat;
Oid opid;
if (attn == nkeycols - 1)
- strat = RTOverlapStrategyNumber;
+ cmptype = COMPARE_OVERLAP;
else
- strat = RTEqualStrategyNumber;
- GetOperatorFromWellKnownStrategy(opclassOids[attn],
InvalidOid,
-
&opid, &strat);
+ cmptype = COMPARE_EQ;
+ GetOperatorFromCompareType(opclassOids[attn],
InvalidOid, cmptype, &opid, &strat);
indexInfo->ii_ExclusionOps[attn] = opid;
indexInfo->ii_ExclusionProcs[attn] = get_opcode(opid);
indexInfo->ii_ExclusionStrats[attn] = strat;
@@ -2422,30 +2422,28 @@ GetDefaultOpClass(Oid type_id, Oid am_id)
}
/*
- * GetOperatorFromWellKnownStrategy
+ * GetOperatorFromCompareType
*
* opclass - the opclass to use
* rhstype - the type for the right-hand side, or InvalidOid to use the type
of the given opclass.
+ * cmptype - kind of operator to find
* opid - holds the operator we found
- * strat - holds the input and output strategy number
+ * strat - holds the output strategy number
*
- * Finds an operator from a "well-known" strategy number. This is used for
- * temporal index constraints (and other temporal features) to look up
- * equality and overlaps operators, since the strategy numbers for non-btree
- * indexams need not follow any fixed scheme. We ask an opclass support
- * function to translate from the well-known number to the internal value. If
- * the function isn't defined or it gives no result, we return
- * InvalidStrategy.
+ * Finds an operator from a CompareType. This is used for temporal index
+ * constraints (and other temporal features) to look up equality and overlaps
+ * operators. We ask an opclass support function to translate from the
+ * compare type to the internal strategy numbers. If the function isn't
+ * defined or it gives no result, we set *strat to InvalidStrategy.
*/
void
-GetOperatorFromWellKnownStrategy(Oid opclass, Oid rhstype,
- Oid *opid,
StrategyNumber *strat)
+GetOperatorFromCompareType(Oid opclass, Oid rhstype, CompareType cmptype,
+ Oid *opid, StrategyNumber
*strat)
{
Oid opfamily;
Oid opcintype;
- StrategyNumber instrat = *strat;
- Assert(instrat == RTEqualStrategyNumber || instrat ==
RTOverlapStrategyNumber || instrat == RTContainedByStrategyNumber);
+ Assert(cmptype == COMPARE_EQ || cmptype == COMPARE_OVERLAP || cmptype
== COMPARE_CONTAINED_BY);
*opid = InvalidOid;
@@ -2457,7 +2455,7 @@ GetOperatorFromWellKnownStrategy(Oid opclass, Oid rhstype,
* For now we only need GiST support, but this could support
other
* indexams if we wanted.
*/
- *strat = GistTranslateStratnum(opclass, instrat);
+ *strat = GistTranslateStratnum(opclass, cmptype);
if (*strat == InvalidStrategy)
{
HeapTuple tuple;
@@ -2468,11 +2466,11 @@ GetOperatorFromWellKnownStrategy(Oid opclass, Oid
rhstype,
ereport(ERROR,
errcode(ERRCODE_UNDEFINED_OBJECT),
- instrat == RTEqualStrategyNumber ?
errmsg("could not identify an equality operator for type %s",
format_type_be(opcintype)) :
- instrat == RTOverlapStrategyNumber ?
errmsg("could not identify an overlaps operator for type %s",
format_type_be(opcintype)) :
- instrat == RTContainedByStrategyNumber
? errmsg("could not identify a contained-by operator for type %s",
format_type_be(opcintype)) : 0,
- errdetail("Could not translate strategy
number %d for operator class \"%s\" for access method \"%s\".",
- instrat,
NameStr(((Form_pg_opclass) GETSTRUCT(tuple))->opcname), "gist"));
+ cmptype = COMPARE_EQ ? errmsg("could
not identify an equality operator for type %s", format_type_be(opcintype)) :
+ cmptype == COMPARE_OVERLAP ?
errmsg("could not identify an overlaps operator for type %s",
format_type_be(opcintype)) :
+ cmptype == COMPARE_CONTAINED_BY ?
errmsg("could not identify a contained-by operator for type %s",
format_type_be(opcintype)) : 0,
+ errdetail("Could not translate compare
type %d for operator class \"%s\" for access method \"%s\".",
+ cmptype,
NameStr(((Form_pg_opclass) GETSTRUCT(tuple))->opcname), "gist"));
}
/*
@@ -2495,9 +2493,9 @@ GetOperatorFromWellKnownStrategy(Oid opclass, Oid rhstype,
ereport(ERROR,
errcode(ERRCODE_UNDEFINED_OBJECT),
- instrat == RTEqualStrategyNumber ?
errmsg("could not identify an equality operator for type %s",
format_type_be(opcintype)) :
- instrat == RTOverlapStrategyNumber ?
errmsg("could not identify an overlaps operator for type %s",
format_type_be(opcintype)) :
- instrat == RTContainedByStrategyNumber ?
errmsg("could not identify a contained-by operator for type %s",
format_type_be(opcintype)) : 0,
+ cmptype == COMPARE_EQ ? errmsg("could not
identify an equality operator for type %s", format_type_be(opcintype)) :
+ cmptype == COMPARE_OVERLAP ? errmsg("could not
identify an overlaps operator for type %s", format_type_be(opcintype)) :
+ cmptype == COMPARE_CONTAINED_BY ? errmsg("could
not identify a contained-by operator for type %s", format_type_be(opcintype)) :
0,
errdetail("There is no suitable operator in
operator family \"%s\" for access method \"%s\".",
NameStr(((Form_pg_opfamily)
GETSTRUCT(tuple))->opfname), "gist"));
}
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 6ccae4cb4a8..aef672d278d 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -9972,7 +9972,7 @@ ATAddForeignKeyConstraint(List **wqueue, AlteredTableInfo
*tab, Relation rel,
if (with_period)
{
- StrategyNumber rtstrategy;
+ CompareType cmptype;
bool for_overlaps = with_period && i ==
numpks - 1;
/*
@@ -9982,14 +9982,14 @@ ATAddForeignKeyConstraint(List **wqueue,
AlteredTableInfo *tab, Relation rel,
if (amid != GIST_AM_OID)
elog(ERROR, "only GiST indexes are supported
for temporal foreign keys");
- rtstrategy = for_overlaps ? RTOverlapStrategyNumber :
RTEqualStrategyNumber;
+ cmptype = for_overlaps ? COMPARE_OVERLAP : COMPARE_EQ;
/*
* An opclass can use whatever strategy numbers it
wants, so we
* ask the opclass what number it actually uses instead
of our RT*
* constants.
*/
- eqstrategy = GistTranslateStratnum(opclasses[i],
rtstrategy);
+ eqstrategy = GistTranslateStratnum(opclasses[i],
cmptype);
if (eqstrategy == InvalidStrategy)
{
HeapTuple tuple;
@@ -10003,8 +10003,8 @@ ATAddForeignKeyConstraint(List **wqueue,
AlteredTableInfo *tab, Relation rel,
for_overlaps
? errmsg("could not identify an
overlaps operator for foreign key")
: errmsg("could not identify an
equality operator for foreign key"),
- errdetail("Could not translate
strategy number %d for operator class \"%s\" for access method \"%s\".",
- rtstrategy,
NameStr(((Form_pg_opclass) GETSTRUCT(tuple))->opcname), "gist"));
+ errdetail("Could not translate
compare type %d for operator class \"%s\" for access method \"%s\".",
+ cmptype,
NameStr(((Form_pg_opclass) GETSTRUCT(tuple))->opcname), "gist"));
}
}
else
diff --git a/src/include/access/gist.h b/src/include/access/gist.h
index 22dd04c1418..a8689cfcefe 100644
--- a/src/include/access/gist.h
+++ b/src/include/access/gist.h
@@ -247,6 +247,7 @@ typedef struct
do { (e).key = (k); (e).rel = (r); (e).page = (pg); \
(e).offset = (o); (e).leafkey = (l); } while (0)
-extern StrategyNumber GistTranslateStratnum(Oid opclass, StrategyNumber strat);
+enum CompareType;
+extern StrategyNumber GistTranslateStratnum(Oid opclass, enum CompareType cmp);
#endif /* GIST_H */
diff --git a/src/include/catalog/pg_amproc.dat
b/src/include/catalog/pg_amproc.dat
index 5d7fe292bf6..a04828fde96 100644
--- a/src/include/catalog/pg_amproc.dat
+++ b/src/include/catalog/pg_amproc.dat
@@ -508,7 +508,7 @@
amprocrighttype => 'box', amprocnum => '8', amproc => 'gist_box_distance' },
{ amprocfamily => 'gist/box_ops', amproclefttype => 'box',
amprocrighttype => 'box', amprocnum => '12',
- amproc => 'gist_stratnum_identity' },
+ amproc => 'gist_stratnum_common' },
{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
amprocrighttype => 'polygon', amprocnum => '1',
amproc => 'gist_poly_consistent' },
@@ -530,7 +530,7 @@
amproc => 'gist_poly_distance' },
{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon',
amprocrighttype => 'polygon', amprocnum => '12',
- amproc => 'gist_stratnum_identity' },
+ amproc => 'gist_stratnum_common' },
{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
amprocrighttype => 'circle', amprocnum => '1',
amproc => 'gist_circle_consistent' },
@@ -551,7 +551,7 @@
amproc => 'gist_circle_distance' },
{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle',
amprocrighttype => 'circle', amprocnum => '12',
- amproc => 'gist_stratnum_identity' },
+ amproc => 'gist_stratnum_common' },
{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector',
amprocrighttype => 'tsvector', amprocnum => '1',
amproc => 'gtsvector_consistent(internal,tsvector,int2,oid,internal)' },
@@ -608,7 +608,7 @@
amproc => 'range_gist_same' },
{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange',
amprocrighttype => 'anyrange', amprocnum => '12',
- amproc => 'gist_stratnum_identity' },
+ amproc => 'gist_stratnum_common' },
{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
amprocrighttype => 'inet', amprocnum => '1',
amproc => 'inet_gist_consistent' },
@@ -627,7 +627,7 @@
amprocrighttype => 'inet', amprocnum => '9', amproc => 'inet_gist_fetch' },
{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet',
amprocrighttype => 'inet', amprocnum => '12',
- amproc => 'gist_stratnum_identity' },
+ amproc => 'gist_stratnum_common' },
{ amprocfamily => 'gist/multirange_ops', amproclefttype => 'anymultirange',
amprocrighttype => 'anymultirange', amprocnum => '1',
amproc => 'multirange_gist_consistent' },
@@ -648,7 +648,7 @@
amproc => 'range_gist_same' },
{ amprocfamily => 'gist/multirange_ops', amproclefttype => 'anymultirange',
amprocrighttype => 'anymultirange', amprocnum => '12',
- amproc => 'gist_stratnum_identity' },
+ amproc => 'gist_stratnum_common' },
# gin
{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray',
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 9575524007f..988b8a336f7 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -12403,8 +12403,8 @@
# GiST stratnum implementations
{ oid => '8047', descr => 'GiST support',
- proname => 'gist_stratnum_identity', prorettype => 'int2',
- proargtypes => 'int2',
- prosrc => 'gist_stratnum_identity' },
+ proname => 'gist_stratnum_common', prorettype => 'int2',
+ proargtypes => 'int4',
+ prosrc => 'gist_stratnum_common' },
]
diff --git a/src/include/commands/defrem.h b/src/include/commands/defrem.h
index 5fd095ea177..bf44d111c00 100644
--- a/src/include/commands/defrem.h
+++ b/src/include/commands/defrem.h
@@ -50,8 +50,8 @@ extern bool CheckIndexCompatible(Oid oldId,
extern Oid GetDefaultOpClass(Oid type_id, Oid am_id);
extern Oid ResolveOpClass(const List *opclass, Oid attrType,
const char
*accessMethodName, Oid accessMethodId);
-extern void GetOperatorFromWellKnownStrategy(Oid opclass, Oid rhstype,
-
Oid *opid, StrategyNumber *strat);
+extern void GetOperatorFromCompareType(Oid opclass, Oid rhstype, CompareType
cmptype,
+ Oid
*opid, StrategyNumber *strat);
/* commands/functioncmds.c */
extern ObjectAddress CreateFunction(ParseState *pstate, CreateFunctionStmt
*stmt);
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 107eb36a340..60a8c62fca4 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1446,7 +1446,7 @@ typedef struct RowExpr
* (some of) the operators without needing hardcoded knowledge of index AM's
* strategy numbering.
*
- * XXX Currently, this mapping is not fully developed and the values are
+ * XXX Currently, this mapping is not fully developed and most values are
* chosen to match btree strategy numbers, which is not going to work very
* well for other access methods.
*/
@@ -1458,6 +1458,8 @@ typedef enum CompareType
COMPARE_GE = 4, /* BTGreaterEqualStrategyNumber
*/
COMPARE_GT = 5, /* BTGreaterStrategyNumber */
COMPARE_NE = 6, /* no such btree strategy */
+ COMPARE_OVERLAP,
+ COMPARE_CONTAINED_BY,
} CompareType;
/*
diff --git a/src/test/regress/expected/misc_functions.out
b/src/test/regress/expected/misc_functions.out
index 8c73d2b621e..dc28fcb310e 100644
--- a/src/test/regress/expected/misc_functions.out
+++ b/src/test/regress/expected/misc_functions.out
@@ -891,15 +891,15 @@ SELECT pg_column_toast_chunk_id(a) IS NULL,
DROP TABLE test_chunk_id;
DROP FUNCTION explain_mask_costs(text, bool, bool, bool, bool);
-- test stratnum support functions
-SELECT gist_stratnum_identity(3::smallint);
- gist_stratnum_identity
-------------------------
- 3
+SELECT gist_stratnum_common(7);
+ gist_stratnum_common
+----------------------
+ 3
(1 row)
-SELECT gist_stratnum_identity(18::smallint);
- gist_stratnum_identity
-------------------------
- 18
+SELECT gist_stratnum_common(3);
+ gist_stratnum_common
+----------------------
+ 18
(1 row)
diff --git a/src/test/regress/sql/misc_functions.sql
b/src/test/regress/sql/misc_functions.sql
index 0a0c6e5a6bb..81ef45d128c 100644
--- a/src/test/regress/sql/misc_functions.sql
+++ b/src/test/regress/sql/misc_functions.sql
@@ -401,5 +401,5 @@ CREATE TABLE test_chunk_id (a TEXT, b TEXT STORAGE
EXTERNAL);
DROP FUNCTION explain_mask_costs(text, bool, bool, bool, bool);
-- test stratnum support functions
-SELECT gist_stratnum_identity(3::smallint);
-SELECT gist_stratnum_identity(18::smallint);
+SELECT gist_stratnum_common(7);
+SELECT gist_stratnum_common(3);
--
2.47.1
