*
* rtree_gist.c
* pg_amproc entries for GiSTs over 2-D boxes.
- * This gives R-tree behavior, with Guttman's poly-time split algorithm.
*
+ * This gives R-tree behavior, with Guttman's poly-time split algorithm.
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/contrib/rtree_gist/rtree_gist.c,v 1.12 2005/05/25 21:40:40 momjian Exp $
+ * $PostgreSQL: pgsql/contrib/rtree_gist/rtree_gist.c,v 1.13 2005/06/24 00:18:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/*
- * * if entry is not leaf, use gbox_internal_consistent, * else use
+ * if entry is not leaf, use rtree_internal_consistent, else use
* gbox_leaf_consistent
*/
if (!(DatumGetPointer(entry->key) != NULL && query))
bool result;
/*
- * * if entry is not leaf, use gbox_internal_consistent, * else use
- * gbox_leaf_consistent
+ * Since the operators are marked lossy anyway, we can just use
+ * rtree_internal_consistent even at leaf nodes. (This works
+ * in part because the index entries are bounding Boxes not polygons.)
*/
if (!(DatumGetPointer(entry->key) != NULL && query))
PG_RETURN_BOOL(FALSE);
switch (strategy)
{
case RTLeftStrategyNumber:
+ retval = !DatumGetBool(DirectFunctionCall2(box_overright, PointerGetDatum(key), PointerGetDatum(query)));
+ break;
case RTOverLeftStrategyNumber:
- retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query)));
+ retval = !DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTOverlapStrategyNumber:
retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTOverRightStrategyNumber:
+ retval = !DatumGetBool(DirectFunctionCall2(box_left, PointerGetDatum(key), PointerGetDatum(query)));
+ break;
case RTRightStrategyNumber:
- retval = DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query)));
+ retval = !DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query)));
break;
case RTSameStrategyNumber:
case RTContainsStrategyNumber:
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/common/indexvalid.c,v 1.33 2004/12/31 21:59:07 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/access/common/indexvalid.c,v 1.34 2005/06/24 00:18:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
test = FunctionCall2(&key->sk_func, datum, key->sk_argument);
- if (!DatumGetBool(test))
- return false;
+ if (key->sk_flags & SK_NEGATE)
+ {
+ if (DatumGetBool(test))
+ return false;
+ }
+ else
+ {
+ if (!DatumGetBool(test))
+ return false;
+ }
key++;
scanKeySize--;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/rtree/rtscan.c,v 1.58 2005/03/29 00:16:53 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/rtree/rtscan.c,v 1.59 2005/06/24 00:18:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* Scans on internal pages use different operators than they do on
* leaf pages. For example, if the user wants all boxes that
* exactly match (x1,y1,x2,y2), then on internal pages we need to
- * find all boxes that contain (x1,y1,x2,y2).
+ * find all boxes that contain (x1,y1,x2,y2). rtstrat.c knows
+ * how to pick the opclass member to use for internal pages.
+ * In some cases we need to negate the result of the opclass member.
*/
for (i = 0; i < s->numberOfKeys; i++)
{
AttrNumber attno = s->keyData[i].sk_attno;
Oid opclass;
+ Oid subtype;
+ StrategyNumber orig_strategy;
StrategyNumber int_strategy;
Oid int_oper;
RegProcedure int_proc;
+ int int_flags;
opclass = s->indexRelation->rd_indclass->values[attno - 1];
- int_strategy = RTMapToInternalOperator(s->keyData[i].sk_strategy);
- int_oper = get_opclass_member(opclass,
- s->keyData[i].sk_subtype,
- int_strategy);
+ subtype = s->keyData[i].sk_subtype;
+ orig_strategy = s->keyData[i].sk_strategy;
+ int_strategy = RTMapToInternalOperator(orig_strategy);
+ int_oper = get_opclass_member(opclass, subtype, int_strategy);
+ Assert(OidIsValid(int_oper));
int_proc = get_opcode(int_oper);
+ int_flags = s->keyData[i].sk_flags;
+ if (RTMapToInternalNegate(orig_strategy))
+ int_flags |= SK_NEGATE;
ScanKeyEntryInitialize(&(p->s_internalKey[i]),
- s->keyData[i].sk_flags,
+ int_flags,
attno,
int_strategy,
- s->keyData[i].sk_subtype,
+ subtype,
int_proc,
s->keyData[i].sk_argument);
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/rtree/rtstrat.c,v 1.25 2004/12/31 21:59:26 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/access/rtree/rtstrat.c,v 1.26 2005/06/24 00:18:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* the leaf we search for equality.
*
* This array maps leaf search operators to the internal search operators.
- * We assume the normal ordering on operators:
- *
- * left, left-or-overlap, overlap, right-or-overlap, right, same,
- * contains, contained-by
*/
static const StrategyNumber RTOperMap[RTNStrategies] = {
- RTOverLeftStrategyNumber,
- RTOverLeftStrategyNumber,
- RTOverlapStrategyNumber,
- RTOverRightStrategyNumber,
- RTOverRightStrategyNumber,
- RTContainsStrategyNumber,
- RTContainsStrategyNumber,
- RTOverlapStrategyNumber
+ RTOverRightStrategyNumber, /* left */
+ RTRightStrategyNumber, /* overleft */
+ RTOverlapStrategyNumber, /* overlap */
+ RTLeftStrategyNumber, /* overright */
+ RTOverLeftStrategyNumber, /* right */
+ RTContainsStrategyNumber, /* same */
+ RTContainsStrategyNumber, /* contains */
+ RTOverlapStrategyNumber /* contained-by */
+};
+
+/*
+ * We may need to negate the result of the selected operator. (This could
+ * be avoided by expanding the set of operators required for an opclass.)
+ */
+static const bool RTNegateMap[RTNStrategies] = {
+ true, /* left */
+ true, /* overleft */
+ false, /* overlap */
+ true, /* overright */
+ true, /* right */
+ false, /* same */
+ false, /* contains */
+ false /* contained-by */
};
Assert(strat > 0 && strat <= RTNStrategies);
return RTOperMap[strat - 1];
}
+
+bool
+RTMapToInternalNegate(StrategyNumber strat)
+{
+ Assert(strat > 0 && strat <= RTNStrategies);
+ return RTNegateMap[strat - 1];
+}
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/access/rtree.h,v 1.39 2005/06/06 17:01:24 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/access/rtree.h,v 1.40 2005/06/24 00:18:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* rtstrat.c */
extern StrategyNumber RTMapToInternalOperator(StrategyNumber strat);
+extern bool RTMapToInternalNegate(StrategyNumber strat);
#endif /* RTREE_H */
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/access/skey.h,v 1.28 2004/12/31 22:03:21 pgsql Exp $
+ * $PostgreSQL: pgsql/src/include/access/skey.h,v 1.29 2005/06/24 00:18:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* ScanKeyData sk_flags */
#define SK_ISNULL 0x0001 /* sk_argument is NULL */
#define SK_UNARY 0x0002 /* unary operator (currently unsupported) */
+#define SK_NEGATE 0x0004 /* must negate the function result */
/*
projects / postgresql / commitdiff