1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
2003-11-09 22:30:38 +01:00
|
|
|
* nbtutils.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* Utility code for Postgres btree implementation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2003-08-04 04:40:20 +02:00
|
|
|
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2003-11-09 22:30:38 +01:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.55 2003/11/09 21:30:35 tgl Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
1998-04-27 06:08:07 +02:00
|
|
|
#include "postgres.h"
|
1996-10-23 09:42:13 +02:00
|
|
|
|
1998-04-27 06:08:07 +02:00
|
|
|
#include "access/genam.h"
|
|
|
|
#include "access/nbtree.h"
|
2000-11-21 22:16:06 +01:00
|
|
|
#include "catalog/catalog.h"
|
1998-04-27 06:08:07 +02:00
|
|
|
#include "executor/execdebug.h"
|
2003-11-09 22:30:38 +01:00
|
|
|
#include "utils/lsyscache.h"
|
2002-05-24 20:57:57 +02:00
|
|
|
|
|
|
|
|
2000-02-18 07:32:39 +01:00
|
|
|
/*
|
|
|
|
* _bt_mkscankey
|
|
|
|
* Build a scan key that contains comparison data from itup
|
|
|
|
* as well as comparator routines appropriate to the key datatypes.
|
|
|
|
*
|
2000-07-21 08:42:39 +02:00
|
|
|
* The result is intended for use with _bt_compare().
|
2000-02-18 07:32:39 +01:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
ScanKey
|
1996-07-09 08:22:35 +02:00
|
|
|
_bt_mkscankey(Relation rel, IndexTuple itup)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
ScanKey skey;
|
|
|
|
TupleDesc itupdesc;
|
|
|
|
int natts;
|
|
|
|
int i;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
itupdesc = RelationGetDescr(rel);
|
2000-02-18 07:32:39 +01:00
|
|
|
natts = RelationGetNumberOfAttributes(rel);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
skey = (ScanKey) palloc(natts * sizeof(ScanKeyData));
|
|
|
|
|
|
|
|
for (i = 0; i < natts; i++)
|
1997-03-24 09:48:16 +01:00
|
|
|
{
|
2003-11-09 22:30:38 +01:00
|
|
|
FmgrInfo *procinfo;
|
|
|
|
Datum arg;
|
|
|
|
bool null;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can use the cached support procs since no cross-type comparison
|
|
|
|
* can be needed.
|
|
|
|
*/
|
2001-10-07 01:21:45 +02:00
|
|
|
procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
|
1997-09-07 07:04:48 +02:00
|
|
|
arg = index_getattr(itup, i + 1, itupdesc, &null);
|
2001-10-07 01:21:45 +02:00
|
|
|
ScanKeyEntryInitializeWithInfo(&skey[i],
|
2003-11-09 22:30:38 +01:00
|
|
|
null ? SK_ISNULL : 0,
|
2001-10-07 01:21:45 +02:00
|
|
|
(AttrNumber) (i + 1),
|
2003-11-09 22:30:38 +01:00
|
|
|
InvalidStrategy,
|
2001-10-07 01:21:45 +02:00
|
|
|
procinfo,
|
2003-11-09 22:30:38 +01:00
|
|
|
arg,
|
|
|
|
itupdesc->attrs[i]->atttypid);
|
2000-02-18 07:32:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return skey;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* _bt_mkscankey_nodata
|
|
|
|
* Build a scan key that contains comparator routines appropriate to
|
2003-11-09 22:30:38 +01:00
|
|
|
* the key datatypes, but no comparison data. The comparison data
|
|
|
|
* ultimately used must match the key datatypes.
|
2000-02-18 07:32:39 +01:00
|
|
|
*
|
2000-07-21 08:42:39 +02:00
|
|
|
* The result cannot be used with _bt_compare(). Currently this
|
2003-11-09 22:30:38 +01:00
|
|
|
* routine is only called by nbtsort.c and tuplesort.c, which have
|
|
|
|
* their own comparison routines.
|
2000-02-18 07:32:39 +01:00
|
|
|
*/
|
|
|
|
ScanKey
|
|
|
|
_bt_mkscankey_nodata(Relation rel)
|
|
|
|
{
|
|
|
|
ScanKey skey;
|
2003-11-09 22:30:38 +01:00
|
|
|
TupleDesc itupdesc;
|
2000-02-18 07:32:39 +01:00
|
|
|
int natts;
|
|
|
|
int i;
|
|
|
|
|
2003-11-09 22:30:38 +01:00
|
|
|
itupdesc = RelationGetDescr(rel);
|
2000-02-18 07:32:39 +01:00
|
|
|
natts = RelationGetNumberOfAttributes(rel);
|
|
|
|
|
|
|
|
skey = (ScanKey) palloc(natts * sizeof(ScanKeyData));
|
|
|
|
|
|
|
|
for (i = 0; i < natts; i++)
|
|
|
|
{
|
2003-11-09 22:30:38 +01:00
|
|
|
FmgrInfo *procinfo;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can use the cached support procs since no cross-type comparison
|
|
|
|
* can be needed.
|
|
|
|
*/
|
2001-10-07 01:21:45 +02:00
|
|
|
procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
|
|
|
|
ScanKeyEntryInitializeWithInfo(&skey[i],
|
|
|
|
SK_ISNULL,
|
|
|
|
(AttrNumber) (i + 1),
|
2003-11-09 22:30:38 +01:00
|
|
|
InvalidStrategy,
|
2001-10-07 01:21:45 +02:00
|
|
|
procinfo,
|
2003-11-09 22:30:38 +01:00
|
|
|
(Datum) 0,
|
|
|
|
itupdesc->attrs[i]->atttypid);
|
1997-03-24 09:48:16 +01:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return skey;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2000-02-18 07:32:39 +01:00
|
|
|
/*
|
|
|
|
* free a scan key made by either _bt_mkscankey or _bt_mkscankey_nodata.
|
|
|
|
*/
|
1996-07-09 08:22:35 +02:00
|
|
|
void
|
|
|
|
_bt_freeskey(ScanKey skey)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
pfree(skey);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2000-07-21 21:21:00 +02:00
|
|
|
/*
|
|
|
|
* free a retracement stack made by _bt_search.
|
|
|
|
*/
|
1996-07-09 08:22:35 +02:00
|
|
|
void
|
|
|
|
_bt_freestack(BTStack stack)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
BTStack ostack;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
while (stack != (BTStack) NULL)
|
|
|
|
{
|
|
|
|
ostack = stack;
|
|
|
|
stack = stack->bts_parent;
|
|
|
|
pfree(ostack);
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2000-07-21 21:21:00 +02:00
|
|
|
/*
|
|
|
|
* Construct a BTItem from a plain IndexTuple.
|
|
|
|
*
|
|
|
|
* This is now useless code, since a BTItem *is* an index tuple with
|
2001-03-22 05:01:46 +01:00
|
|
|
* no extra stuff. We hang onto it for the moment to preserve the
|
2000-07-21 21:21:00 +02:00
|
|
|
* notational distinction, in case we want to add some extra stuff
|
|
|
|
* again someday.
|
|
|
|
*/
|
|
|
|
BTItem
|
|
|
|
_bt_formitem(IndexTuple itup)
|
|
|
|
{
|
|
|
|
int nbytes_btitem;
|
|
|
|
BTItem btitem;
|
|
|
|
Size tuplen;
|
|
|
|
|
|
|
|
/* make a copy of the index tuple with room for extra stuff */
|
|
|
|
tuplen = IndexTupleSize(itup);
|
|
|
|
nbytes_btitem = tuplen + (sizeof(BTItemData) - sizeof(IndexTupleData));
|
|
|
|
|
|
|
|
btitem = (BTItem) palloc(nbytes_btitem);
|
|
|
|
memcpy((char *) &(btitem->bti_itup), (char *) itup, tuplen);
|
|
|
|
|
|
|
|
return btitem;
|
|
|
|
}
|
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/*----------
|
1997-09-07 07:04:48 +02:00
|
|
|
* _bt_orderkeys() -- Put keys in a sensible order for conjunctive quals.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2000-07-25 06:47:59 +02:00
|
|
|
* After this routine runs, the scan keys are ordered by index attribute
|
|
|
|
* (all quals for attr 1, then all for attr 2, etc) and within each attr
|
|
|
|
* the keys are ordered by constraint type: ">", ">=", "=", "<=", "<".
|
|
|
|
* Furthermore, redundant keys are eliminated: we keep only the tightest
|
|
|
|
* >/>= bound and the tightest </<= bound, and if there's an = key then
|
|
|
|
* that's the only one returned. (So, we return either a single = key,
|
|
|
|
* or one or two boundary-condition keys for each attr.)
|
|
|
|
*
|
|
|
|
* As a byproduct of this work, we can detect contradictory quals such
|
|
|
|
* as "x = 1 AND x > 2". If we see that, we return so->quals_ok = FALSE,
|
|
|
|
* indicating the scan need not be run at all since no tuples can match.
|
|
|
|
*
|
|
|
|
* Another byproduct is to determine how many quals must be satisfied to
|
|
|
|
* continue the scan. _bt_checkkeys uses this. For example, if the quals
|
|
|
|
* are "x = 1 AND y < 4 AND z < 5", then _bt_checkkeys will reject a tuple
|
|
|
|
* (1,2,7), but we must continue the scan in case there are tuples (1,3,z).
|
|
|
|
* But once we reach tuples like (1,4,z) we can stop scanning because no
|
2001-03-22 05:01:46 +01:00
|
|
|
* later tuples could match. This is reflected by setting
|
2000-07-25 06:47:59 +02:00
|
|
|
* so->numberOfRequiredKeys to the number of leading keys that must be
|
|
|
|
* matched to continue the scan. numberOfRequiredKeys is equal to the
|
|
|
|
* number of leading "=" keys plus the key(s) for the first non "="
|
|
|
|
* attribute, which can be seen to be correct by considering the above
|
|
|
|
* example.
|
|
|
|
*
|
2002-05-24 20:57:57 +02:00
|
|
|
* Furthermore, we detect the case where the index is unique and we have
|
2002-09-04 22:31:48 +02:00
|
|
|
* equality quals for all columns. In this case there can be at most one
|
2002-05-24 20:57:57 +02:00
|
|
|
* (visible) matching tuple. index_getnext uses this to avoid uselessly
|
|
|
|
* continuing the scan after finding one match.
|
|
|
|
*
|
2000-07-25 06:47:59 +02:00
|
|
|
* The initial ordering of the keys is expected to be by attribute already
|
|
|
|
* (see group_clauses_by_indexkey() in indxpath.c). The task here is to
|
|
|
|
* standardize the appearance of multiple keys for the same attribute.
|
|
|
|
*----------
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
void
|
2002-05-24 20:57:57 +02:00
|
|
|
_bt_orderkeys(IndexScanDesc scan)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2002-05-24 20:57:57 +02:00
|
|
|
Relation relation = scan->indexRelation;
|
|
|
|
BTScanOpaque so = (BTScanOpaque) scan->opaque;
|
2001-03-22 05:01:46 +01:00
|
|
|
ScanKeyData xform[BTMaxStrategyNumber];
|
2000-07-25 06:47:59 +02:00
|
|
|
bool init[BTMaxStrategyNumber];
|
2002-05-21 01:51:44 +02:00
|
|
|
int numberOfKeys = so->numberOfKeys;
|
2000-07-25 06:47:59 +02:00
|
|
|
ScanKey key;
|
|
|
|
ScanKey cur;
|
2000-05-30 06:25:00 +02:00
|
|
|
Datum test;
|
1997-09-08 04:41:22 +02:00
|
|
|
int i,
|
|
|
|
j;
|
2000-07-25 06:47:59 +02:00
|
|
|
AttrNumber attno;
|
2002-05-21 01:51:44 +02:00
|
|
|
int new_numberOfKeys;
|
2000-07-25 06:47:59 +02:00
|
|
|
bool allEqualSoFar;
|
|
|
|
|
|
|
|
so->qual_ok = true;
|
|
|
|
so->numberOfRequiredKeys = 0;
|
2002-05-24 20:57:57 +02:00
|
|
|
scan->keys_are_unique = false;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (numberOfKeys < 1)
|
2000-07-25 06:47:59 +02:00
|
|
|
return; /* done if qual-less scan */
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
key = so->keyData;
|
|
|
|
cur = &key[0];
|
2000-07-25 06:47:59 +02:00
|
|
|
/* check input keys are correctly ordered */
|
1997-09-07 07:04:48 +02:00
|
|
|
if (cur->sk_attno != 1)
|
2003-07-21 22:29:40 +02:00
|
|
|
elog(ERROR, "key(s) for attribute 1 missed");
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-11-09 22:30:38 +01:00
|
|
|
#if 0
|
|
|
|
/* XXX verify that operator strategy info is correct */
|
|
|
|
/* XXX this is temporary for debugging; it's pretty expensive */
|
|
|
|
/* XXX can't do it during bootstrap, else will recurse infinitely */
|
|
|
|
{
|
|
|
|
extern bool criticalRelcachesBuilt;
|
|
|
|
static bool inRecursion = false;
|
|
|
|
|
|
|
|
if (criticalRelcachesBuilt && !inRecursion)
|
|
|
|
{
|
|
|
|
inRecursion = true;
|
|
|
|
for (i = 0; i < numberOfKeys; i++)
|
|
|
|
{
|
|
|
|
AttrNumber attno = key[i].sk_attno;
|
|
|
|
Oid opclass;
|
|
|
|
Oid chk_oper;
|
|
|
|
|
|
|
|
opclass = relation->rd_index->indclass[attno-1];
|
|
|
|
chk_oper = get_opclass_member(opclass, key[i].sk_strategy);
|
|
|
|
Assert(key[i].sk_func.fn_oid == get_opcode(chk_oper));
|
|
|
|
}
|
|
|
|
inRecursion = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/* We can short-circuit most of the work if there's just one key */
|
1997-09-07 07:04:48 +02:00
|
|
|
if (numberOfKeys == 1)
|
1997-03-18 19:41:37 +01:00
|
|
|
{
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* We don't use indices for 'A is null' and 'A is not null'
|
2000-07-25 06:47:59 +02:00
|
|
|
* currently and 'A < = > <> NULL' will always fail - so qual is
|
|
|
|
* not Ok if comparison value is NULL. - vadim 03/21/97
|
1997-03-18 19:41:37 +01:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (cur->sk_flags & SK_ISNULL)
|
2000-07-25 06:47:59 +02:00
|
|
|
so->qual_ok = false;
|
2002-05-24 20:57:57 +02:00
|
|
|
else if (relation->rd_index->indisunique &&
|
|
|
|
relation->rd_rel->relnatts == 1)
|
|
|
|
{
|
|
|
|
/* it's a unique index, do we have an equality qual? */
|
2003-11-09 22:30:38 +01:00
|
|
|
if (cur->sk_strategy == BTEqualStrategyNumber)
|
2002-05-24 20:57:57 +02:00
|
|
|
scan->keys_are_unique = true;
|
|
|
|
}
|
2000-07-25 06:47:59 +02:00
|
|
|
so->numberOfRequiredKeys = 1;
|
1997-09-07 07:04:48 +02:00
|
|
|
return;
|
1997-03-18 19:41:37 +01:00
|
|
|
}
|
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/*
|
|
|
|
* Otherwise, do the full set of pushups.
|
|
|
|
*/
|
|
|
|
new_numberOfKeys = 0;
|
|
|
|
allEqualSoFar = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize for processing of keys for attr 1.
|
|
|
|
*
|
2001-03-22 05:01:46 +01:00
|
|
|
* xform[i] holds a copy of the current scan key of strategy type i+1, if
|
|
|
|
* any; init[i] is TRUE if we have found such a key for this attr.
|
2000-07-25 06:47:59 +02:00
|
|
|
*/
|
|
|
|
attno = 1;
|
2001-03-22 05:01:46 +01:00
|
|
|
MemSet(xform, 0, sizeof(xform)); /* not really necessary */
|
2000-07-25 06:47:59 +02:00
|
|
|
MemSet(init, 0, sizeof(init));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Loop iterates from 0 to numberOfKeys inclusive; we use the last
|
|
|
|
* pass to handle after-last-key processing. Actual exit from the
|
|
|
|
* loop is at the "break" statement below.
|
|
|
|
*/
|
2001-03-22 05:01:46 +01:00
|
|
|
for (i = 0;; cur++, i++)
|
1997-03-18 19:41:37 +01:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (i < numberOfKeys)
|
2000-07-25 06:47:59 +02:00
|
|
|
{
|
|
|
|
/* See comments above: any NULL implies cannot match qual */
|
|
|
|
if (cur->sk_flags & SK_ISNULL)
|
|
|
|
{
|
|
|
|
so->qual_ok = false;
|
2001-03-22 05:01:46 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Quit processing so we don't try to invoke comparison
|
2000-07-25 06:47:59 +02:00
|
|
|
* routines on NULLs.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* If we are at the end of the keys for a particular attr, finish
|
|
|
|
* up processing and emit the cleaned-up keys.
|
2000-07-25 06:47:59 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (i == numberOfKeys || cur->sk_attno != attno)
|
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
bool priorAllEqualSoFar = allEqualSoFar;
|
|
|
|
|
|
|
|
/* check input keys are correctly ordered */
|
|
|
|
if (i < numberOfKeys && cur->sk_attno != attno + 1)
|
2003-07-21 22:29:40 +02:00
|
|
|
elog(ERROR, "key(s) for attribute %d missed", attno + 1);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If = has been specified, no other key will be used. In case
|
2000-07-25 06:47:59 +02:00
|
|
|
* of key > 2 && key == 1 and so on we have to set qual_ok to
|
|
|
|
* false before discarding the other keys.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
if (init[BTEqualStrategyNumber - 1])
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
ScanKeyData *eq,
|
|
|
|
*chk;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
eq = &xform[BTEqualStrategyNumber - 1];
|
|
|
|
for (j = BTMaxStrategyNumber; --j >= 0;)
|
|
|
|
{
|
2001-03-22 05:01:46 +01:00
|
|
|
if (!init[j] ||
|
2000-07-25 06:47:59 +02:00
|
|
|
j == (BTEqualStrategyNumber - 1))
|
1997-09-07 07:04:48 +02:00
|
|
|
continue;
|
|
|
|
chk = &xform[j];
|
2003-11-09 22:30:38 +01:00
|
|
|
test = FunctionCall2(&chk->sk_func,
|
|
|
|
eq->sk_argument,
|
|
|
|
chk->sk_argument);
|
2000-05-30 06:25:00 +02:00
|
|
|
if (!DatumGetBool(test))
|
2000-07-25 06:47:59 +02:00
|
|
|
so->qual_ok = false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
2000-07-25 06:47:59 +02:00
|
|
|
init[BTLessStrategyNumber - 1] = false;
|
|
|
|
init[BTLessEqualStrategyNumber - 1] = false;
|
|
|
|
init[BTGreaterEqualStrategyNumber - 1] = false;
|
|
|
|
init[BTGreaterStrategyNumber - 1] = false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1999-09-27 20:20:21 +02:00
|
|
|
else
|
2000-07-25 06:47:59 +02:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* No "=" for this key, so we're done with required keys
|
|
|
|
*/
|
|
|
|
allEqualSoFar = false;
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/* keep only one of <, <= */
|
1997-09-07 07:04:48 +02:00
|
|
|
if (init[BTLessStrategyNumber - 1]
|
|
|
|
&& init[BTLessEqualStrategyNumber - 1])
|
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
ScanKeyData *lt = &xform[BTLessStrategyNumber - 1];
|
|
|
|
ScanKeyData *le = &xform[BTLessEqualStrategyNumber - 1];
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-11-09 22:30:38 +01:00
|
|
|
test = FunctionCall2(&le->sk_func,
|
|
|
|
lt->sk_argument,
|
|
|
|
le->sk_argument);
|
2000-05-30 06:25:00 +02:00
|
|
|
if (DatumGetBool(test))
|
2000-07-25 06:47:59 +02:00
|
|
|
init[BTLessEqualStrategyNumber - 1] = false;
|
1997-09-07 07:04:48 +02:00
|
|
|
else
|
2000-07-25 06:47:59 +02:00
|
|
|
init[BTLessStrategyNumber - 1] = false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/* keep only one of >, >= */
|
1997-09-07 07:04:48 +02:00
|
|
|
if (init[BTGreaterStrategyNumber - 1]
|
|
|
|
&& init[BTGreaterEqualStrategyNumber - 1])
|
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
ScanKeyData *gt = &xform[BTGreaterStrategyNumber - 1];
|
|
|
|
ScanKeyData *ge = &xform[BTGreaterEqualStrategyNumber - 1];
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-11-09 22:30:38 +01:00
|
|
|
test = FunctionCall2(&ge->sk_func,
|
|
|
|
gt->sk_argument,
|
|
|
|
ge->sk_argument);
|
2000-05-30 06:25:00 +02:00
|
|
|
if (DatumGetBool(test))
|
2000-07-25 06:47:59 +02:00
|
|
|
init[BTGreaterEqualStrategyNumber - 1] = false;
|
1997-09-07 07:04:48 +02:00
|
|
|
else
|
2000-07-25 06:47:59 +02:00
|
|
|
init[BTGreaterStrategyNumber - 1] = false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/*
|
|
|
|
* Emit the cleaned-up keys back into the key[] array in the
|
|
|
|
* correct order. Note we are overwriting our input here!
|
|
|
|
* It's OK because (a) xform[] is a physical copy of the keys
|
2001-03-22 05:01:46 +01:00
|
|
|
* we want, (b) we cannot emit more keys than we input, so we
|
|
|
|
* won't overwrite as-yet-unprocessed keys.
|
2000-07-25 06:47:59 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
for (j = BTMaxStrategyNumber; --j >= 0;)
|
2000-07-25 06:47:59 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (init[j])
|
2000-07-25 06:47:59 +02:00
|
|
|
memcpy(&key[new_numberOfKeys++], &xform[j],
|
|
|
|
sizeof(ScanKeyData));
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/*
|
|
|
|
* If all attrs before this one had "=", include these keys
|
|
|
|
* into the required-keys count.
|
|
|
|
*/
|
|
|
|
if (priorAllEqualSoFar)
|
|
|
|
so->numberOfRequiredKeys = new_numberOfKeys;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/*
|
|
|
|
* Exit loop here if done.
|
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (i == numberOfKeys)
|
|
|
|
break;
|
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/* Re-initialize for new attno */
|
1997-09-07 07:04:48 +02:00
|
|
|
attno = cur->sk_attno;
|
2001-03-22 05:01:46 +01:00
|
|
|
MemSet(xform, 0, sizeof(xform)); /* not really necessary */
|
2000-07-25 06:47:59 +02:00
|
|
|
MemSet(init, 0, sizeof(init));
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
2002-05-24 20:57:57 +02:00
|
|
|
/* figure out which strategy this key's operator corresponds to */
|
2003-11-09 22:30:38 +01:00
|
|
|
j = cur->sk_strategy - 1;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/* have we seen one of these before? */
|
|
|
|
if (init[j])
|
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
/* yup, keep the more restrictive value */
|
2000-05-30 06:25:00 +02:00
|
|
|
test = FunctionCall2(&cur->sk_func,
|
2000-07-25 06:47:59 +02:00
|
|
|
cur->sk_argument,
|
|
|
|
xform[j].sk_argument);
|
2000-05-30 06:25:00 +02:00
|
|
|
if (DatumGetBool(test))
|
1997-09-07 07:04:48 +02:00
|
|
|
xform[j].sk_argument = cur->sk_argument;
|
|
|
|
else if (j == (BTEqualStrategyNumber - 1))
|
2001-03-23 05:49:58 +01:00
|
|
|
so->qual_ok = false;
|
|
|
|
/* key == a && key == b, but a != b */
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
/* nope, so remember this scankey */
|
|
|
|
memcpy(&xform[j], cur, sizeof(ScanKeyData));
|
|
|
|
init[j] = true;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
so->numberOfKeys = new_numberOfKeys;
|
2002-05-24 20:57:57 +02:00
|
|
|
|
|
|
|
/*
|
2002-09-04 22:31:48 +02:00
|
|
|
* If unique index and we have equality keys for all columns, set
|
|
|
|
* keys_are_unique flag for higher levels.
|
2002-05-24 20:57:57 +02:00
|
|
|
*/
|
|
|
|
if (allEqualSoFar && relation->rd_index->indisunique &&
|
|
|
|
relation->rd_rel->relnatts == new_numberOfKeys)
|
|
|
|
scan->keys_are_unique = true;
|
|
|
|
}
|
|
|
|
|
2000-07-21 21:21:00 +02:00
|
|
|
/*
|
2000-07-25 06:47:59 +02:00
|
|
|
* Test whether an indextuple satisfies all the scankey conditions.
|
2000-07-21 21:21:00 +02:00
|
|
|
*
|
2000-07-25 06:47:59 +02:00
|
|
|
* If the tuple fails to pass the qual, we also determine whether there's
|
|
|
|
* any need to continue the scan beyond this tuple, and set *continuescan
|
|
|
|
* accordingly. See comments for _bt_orderkeys(), above, about how this is
|
|
|
|
* done.
|
2000-07-21 21:21:00 +02:00
|
|
|
*/
|
1997-03-24 09:48:16 +01:00
|
|
|
bool
|
2000-07-25 06:47:59 +02:00
|
|
|
_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
|
|
|
|
ScanDirection dir, bool *continuescan)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
BTScanOpaque so = (BTScanOpaque) scan->opaque;
|
2002-05-21 01:51:44 +02:00
|
|
|
int keysz = so->numberOfKeys;
|
|
|
|
int keysok;
|
1997-09-08 04:41:22 +02:00
|
|
|
TupleDesc tupdesc;
|
|
|
|
ScanKey key;
|
2000-07-25 06:47:59 +02:00
|
|
|
|
|
|
|
*continuescan = true;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/* If no keys, always scan the whole index */
|
1997-09-07 07:04:48 +02:00
|
|
|
if (keysz == 0)
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-05-21 01:51:44 +02:00
|
|
|
tupdesc = RelationGetDescr(scan->indexRelation);
|
2000-07-25 06:47:59 +02:00
|
|
|
key = so->keyData;
|
|
|
|
keysok = 0;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
IncrIndexProcessed();
|
|
|
|
|
|
|
|
while (keysz > 0)
|
1997-03-24 09:48:16 +01:00
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
Datum datum;
|
|
|
|
bool isNull;
|
|
|
|
Datum test;
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
datum = index_getattr(tuple,
|
2000-07-25 06:47:59 +02:00
|
|
|
key->sk_attno,
|
1997-09-07 07:04:48 +02:00
|
|
|
tupdesc,
|
|
|
|
&isNull);
|
1997-03-24 09:48:16 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/* btree doesn't support 'A is null' clauses, yet */
|
2000-07-25 06:47:59 +02:00
|
|
|
if (key->sk_flags & SK_ISNULL)
|
1999-04-13 19:18:29 +02:00
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
/* we shouldn't get here, really; see _bt_orderkeys() */
|
|
|
|
*continuescan = false;
|
1999-04-13 19:18:29 +02:00
|
|
|
return false;
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
if (isNull)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2000-07-25 06:47:59 +02:00
|
|
|
/*
|
|
|
|
* Since NULLs are sorted after non-NULLs, we know we have
|
|
|
|
* reached the upper limit of the range of values for this
|
2001-03-22 05:01:46 +01:00
|
|
|
* index attr. On a forward scan, we can stop if this qual is
|
|
|
|
* one of the "must match" subset. On a backward scan,
|
2000-07-25 06:47:59 +02:00
|
|
|
* however, we should keep going.
|
|
|
|
*/
|
|
|
|
if (keysok < so->numberOfRequiredKeys &&
|
|
|
|
ScanDirectionIsForward(dir))
|
|
|
|
*continuescan = false;
|
2001-03-22 05:01:46 +01:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/*
|
|
|
|
* In any case, this indextuple doesn't match the qual.
|
|
|
|
*/
|
|
|
|
return false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
2000-07-25 06:47:59 +02:00
|
|
|
|
2003-11-09 22:30:38 +01:00
|
|
|
test = FunctionCall2(&key->sk_func, datum, key->sk_argument);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-11-09 22:30:38 +01:00
|
|
|
if (!DatumGetBool(test))
|
2000-07-25 06:47:59 +02:00
|
|
|
{
|
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* Tuple fails this qual. If it's a required qual, then we
|
|
|
|
* can conclude no further tuples will pass, either.
|
2000-07-25 06:47:59 +02:00
|
|
|
*/
|
|
|
|
if (keysok < so->numberOfRequiredKeys)
|
|
|
|
*continuescan = false;
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
2000-07-25 06:47:59 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
keysok++;
|
2000-07-21 21:21:00 +02:00
|
|
|
key++;
|
|
|
|
keysz--;
|
1997-03-24 09:48:16 +01:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-25 06:47:59 +02:00
|
|
|
/* If we get here, the tuple passes all quals. */
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|