Patches for Vadim's multikey indexing...
This commit is contained in:
parent
c3d637ac3a
commit
d146305065
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/Attic/indexvalid.c,v 1.13 1997/03/12 20:56:32 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/Attic/indexvalid.c,v 1.14 1997/03/18 18:38:19 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -48,7 +48,7 @@ index_keytest(IndexTuple tuple,
|
|||
|
||||
while (scanKeySize > 0) {
|
||||
datum = index_getattr(tuple,
|
||||
1,
|
||||
key[0].sk_attno,
|
||||
tupdesc,
|
||||
&isNull);
|
||||
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.15 1997/02/22 10:04:14 vadim Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.16 1997/03/18 18:38:35 scrappy Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains only the public interface routines.
|
||||
|
@ -423,6 +423,7 @@ btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey)
|
|||
|
||||
/* reset the scan key */
|
||||
so->numberOfKeys = scan->numberOfKeys;
|
||||
so->numberOfFirstKeys = 0;
|
||||
so->qual_ok = 1; /* may be changed by _bt_orderkeys */
|
||||
if (scan->numberOfKeys > 0) {
|
||||
memmove(scan->keyData,
|
||||
|
@ -433,7 +434,9 @@ btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey)
|
|||
so->numberOfKeys * sizeof(ScanKeyData));
|
||||
/* order the keys in the qualification */
|
||||
if (so->numberOfKeys > 1)
|
||||
_bt_orderkeys(scan->relation, &so->numberOfKeys, so->keyData, &so->qual_ok);
|
||||
_bt_orderkeys(scan->relation, so);
|
||||
else
|
||||
so->numberOfFirstKeys = 1;
|
||||
}
|
||||
|
||||
/* finally, be sure that the scan exploits the tree order */
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.14 1997/02/18 17:13:48 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.15 1997/03/18 18:38:41 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -562,7 +562,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
|
|||
Page page;
|
||||
OffsetNumber offnum;
|
||||
RetrieveIndexResult res;
|
||||
BlockNumber blkno;
|
||||
ItemPointer current;
|
||||
BTItem btitem;
|
||||
IndexTuple itup;
|
||||
|
@ -584,31 +583,35 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
|
|||
|
||||
/* we still have the buffer pinned and locked */
|
||||
buf = so->btso_curbuf;
|
||||
blkno = BufferGetBlockNumber(buf);
|
||||
|
||||
/* step one tuple in the appropriate direction */
|
||||
if (!_bt_step(scan, &buf, dir))
|
||||
return ((RetrieveIndexResult) NULL);
|
||||
do
|
||||
{
|
||||
/* step one tuple in the appropriate direction */
|
||||
if (!_bt_step(scan, &buf, dir))
|
||||
return ((RetrieveIndexResult) NULL);
|
||||
|
||||
/* by here, current is the tuple we want to return */
|
||||
offnum = ItemPointerGetOffsetNumber(current);
|
||||
page = BufferGetPage(buf);
|
||||
btitem = (BTItem) PageGetItem(page, PageGetItemId(page, offnum));
|
||||
itup = &btitem->bti_itup;
|
||||
/* by here, current is the tuple we want to return */
|
||||
offnum = ItemPointerGetOffsetNumber(current);
|
||||
page = BufferGetPage(buf);
|
||||
btitem = (BTItem) PageGetItem(page, PageGetItemId(page, offnum));
|
||||
itup = &btitem->bti_itup;
|
||||
|
||||
if (_bt_checkqual(scan, itup)) {
|
||||
res = FormRetrieveIndexResult(current, &(itup->t_tid));
|
||||
if (_bt_checkqual(scan, itup))
|
||||
{
|
||||
res = FormRetrieveIndexResult(current, &(itup->t_tid));
|
||||
|
||||
/* remember which buffer we have pinned and locked */
|
||||
so->btso_curbuf = buf;
|
||||
} else {
|
||||
ItemPointerSetInvalid(current);
|
||||
so->btso_curbuf = InvalidBuffer;
|
||||
_bt_relbuf(rel, buf, BT_READ);
|
||||
res = (RetrieveIndexResult) NULL;
|
||||
}
|
||||
/* remember which buffer we have pinned and locked */
|
||||
so->btso_curbuf = buf;
|
||||
return (res);
|
||||
}
|
||||
|
||||
} while ( _bt_checkforkeys (scan, itup, so->numberOfFirstKeys) );
|
||||
|
||||
ItemPointerSetInvalid(current);
|
||||
so->btso_curbuf = InvalidBuffer;
|
||||
_bt_relbuf(rel, buf, BT_READ);
|
||||
|
||||
return (res);
|
||||
return ((RetrieveIndexResult) NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -660,13 +663,6 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
|
|||
* ordered to take advantage of index ordering) to position ourselves
|
||||
* at the right place in the scan.
|
||||
*/
|
||||
|
||||
/*
|
||||
* XXX -- The attribute number stored in the scan key is the attno
|
||||
* in the heap relation. We need to transmogrify this into
|
||||
* the index relation attno here. For the moment, we have
|
||||
* hardwired attno == 1.
|
||||
*/
|
||||
proc = index_getprocid(rel, 1, BTORDER_PROC);
|
||||
ScanKeyEntryInitialize(&skdata, so->keyData[0].sk_flags, 1, proc,
|
||||
so->keyData[0].sk_argument);
|
||||
|
@ -802,12 +798,20 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
|
|||
btitem = (BTItem) PageGetItem(page, PageGetItemId(page, offnum));
|
||||
itup = &btitem->bti_itup;
|
||||
|
||||
if (_bt_checkqual(scan, itup)) {
|
||||
if ( _bt_checkqual(scan, itup) )
|
||||
{
|
||||
res = FormRetrieveIndexResult(current, &(itup->t_tid));
|
||||
|
||||
/* remember which buffer we have pinned */
|
||||
so->btso_curbuf = buf;
|
||||
} else {
|
||||
}
|
||||
else if ( _bt_checkforkeys (scan, itup, so->numberOfFirstKeys) )
|
||||
{
|
||||
so->btso_curbuf = buf;
|
||||
return (_bt_next (scan, dir));
|
||||
}
|
||||
else
|
||||
{
|
||||
ItemPointerSetInvalid(current);
|
||||
so->btso_curbuf = InvalidBuffer;
|
||||
_bt_relbuf(rel, buf, BT_READ);
|
||||
|
@ -1224,7 +1228,14 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
|
|||
|
||||
/* remember which buffer we have pinned */
|
||||
so->btso_curbuf = buf;
|
||||
} else {
|
||||
}
|
||||
else if ( _bt_checkforkeys (scan, itup, so->numberOfFirstKeys) )
|
||||
{
|
||||
so->btso_curbuf = buf;
|
||||
return (_bt_next (scan, dir));
|
||||
}
|
||||
else
|
||||
{
|
||||
_bt_relbuf(rel, buf, BT_READ);
|
||||
res = (RetrieveIndexResult) NULL;
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.7 1996/11/05 10:35:38 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.8 1997/03/18 18:38:46 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -80,7 +80,7 @@ _bt_freestack(BTStack stack)
|
|||
* more than one qual clauses using this index.
|
||||
*/
|
||||
void
|
||||
_bt_orderkeys(Relation relation, uint16 *numberOfKeys, ScanKey key, uint16 *qual_ok)
|
||||
_bt_orderkeys(Relation relation, BTScanOpaque so)
|
||||
{
|
||||
ScanKey xform;
|
||||
ScanKeyData *cur;
|
||||
|
@ -89,42 +89,137 @@ _bt_orderkeys(Relation relation, uint16 *numberOfKeys, ScanKey key, uint16 *qual
|
|||
long test;
|
||||
int i, j;
|
||||
int init[BTMaxStrategyNumber+1];
|
||||
ScanKey key;
|
||||
uint16 numberOfKeys, new_numberOfKeys = 0;
|
||||
AttrNumber attno = 1;
|
||||
|
||||
/* haven't looked at any strategies yet */
|
||||
for (i = 0; i <= BTMaxStrategyNumber; i++)
|
||||
init[i] = 0;
|
||||
numberOfKeys = so->numberOfKeys;
|
||||
key = so->keyData;
|
||||
|
||||
if ( numberOfKeys <= 1 )
|
||||
return;
|
||||
|
||||
/* get space for the modified array of keys */
|
||||
nbytes = BTMaxStrategyNumber * sizeof(ScanKeyData);
|
||||
xform = (ScanKey) palloc(nbytes);
|
||||
|
||||
cur = &key[0];
|
||||
if ( cur->sk_attno != 1 )
|
||||
elog (WARN, "_bt_orderkeys: key(s) for attribute 1 missed");
|
||||
|
||||
memset(xform, 0, nbytes);
|
||||
|
||||
|
||||
/* get the strategy map for this index/attribute pair */
|
||||
/*
|
||||
* XXX
|
||||
* When we support multiple keys in a single index, this is what
|
||||
* we'll want to do. At present, the planner is hosed, so we
|
||||
* hard-wire the attribute number below. Postgres only does single-
|
||||
* key indices...
|
||||
* map = IndexStrategyGetStrategyMap(RelationGetIndexStrategy(relation),
|
||||
* BTMaxStrategyNumber,
|
||||
* key->data[0].attributeNumber);
|
||||
*/
|
||||
map = IndexStrategyGetStrategyMap(RelationGetIndexStrategy(relation),
|
||||
BTMaxStrategyNumber,
|
||||
1 /* XXX */ );
|
||||
attno);
|
||||
for (j = 0; j <= BTMaxStrategyNumber; j++)
|
||||
init[j] = 0;
|
||||
|
||||
/* check each key passed in */
|
||||
for (i = *numberOfKeys; --i >= 0; ) {
|
||||
cur = &key[i];
|
||||
for (j = BTMaxStrategyNumber; --j >= 0; ) {
|
||||
for (i = 0; ; )
|
||||
{
|
||||
if ( i < numberOfKeys )
|
||||
cur = &key[i];
|
||||
if ( i == numberOfKeys || cur->sk_attno != attno )
|
||||
{
|
||||
if ( cur->sk_attno != attno + 1 && i < numberOfKeys )
|
||||
{
|
||||
elog (WARN, "_bt_orderkeys: key(s) for attribute %d missed", attno + 1);
|
||||
}
|
||||
/*
|
||||
* If = has been specified, no other key will be used.
|
||||
* In case of key < 2 && key == 1 and so on
|
||||
* we have to set qual_ok to 0
|
||||
*/
|
||||
if (init[BTEqualStrategyNumber - 1])
|
||||
{
|
||||
ScanKeyData *eq, *chk;
|
||||
|
||||
eq = &xform[BTEqualStrategyNumber - 1];
|
||||
for (j = BTMaxStrategyNumber; --j >= 0; )
|
||||
{
|
||||
if ( j == (BTEqualStrategyNumber - 1) || init[j] == 0 )
|
||||
continue;
|
||||
chk = &xform[j];
|
||||
test = (long) fmgr(chk->sk_procedure, eq->sk_argument, chk->sk_argument);
|
||||
if (!test)
|
||||
so->qual_ok = 0;
|
||||
}
|
||||
init[BTLessStrategyNumber - 1] = 0;
|
||||
init[BTLessEqualStrategyNumber - 1] = 0;
|
||||
init[BTGreaterEqualStrategyNumber - 1] = 0;
|
||||
init[BTGreaterStrategyNumber - 1] = 0;
|
||||
}
|
||||
|
||||
/* only one of <, <= */
|
||||
if (init[BTLessStrategyNumber - 1]
|
||||
&& init[BTLessEqualStrategyNumber - 1])
|
||||
{
|
||||
ScanKeyData *lt, *le;
|
||||
|
||||
lt = &xform[BTLessStrategyNumber - 1];
|
||||
le = &xform[BTLessEqualStrategyNumber - 1];
|
||||
/*
|
||||
* DO NOT use the cached function stuff here -- this is key
|
||||
* ordering, happens only when the user expresses a hokey
|
||||
* qualification, and gets executed only once, anyway. The
|
||||
* transform maps are hard-coded, and can't be initialized
|
||||
* in the correct way.
|
||||
*/
|
||||
test = (long) fmgr(le->sk_procedure, lt->sk_argument, le->sk_argument);
|
||||
if (test)
|
||||
init[BTLessEqualStrategyNumber - 1] = 0;
|
||||
else
|
||||
init[BTLessStrategyNumber - 1] = 0;
|
||||
}
|
||||
|
||||
/* only one of >, >= */
|
||||
if (init[BTGreaterStrategyNumber - 1]
|
||||
&& init[BTGreaterEqualStrategyNumber - 1])
|
||||
{
|
||||
ScanKeyData *gt, *ge;
|
||||
|
||||
gt = &xform[BTGreaterStrategyNumber - 1];
|
||||
ge = &xform[BTGreaterEqualStrategyNumber - 1];
|
||||
|
||||
/* see note above on function cache */
|
||||
test = (long) fmgr(ge->sk_procedure, gt->sk_argument, ge->sk_argument);
|
||||
if (test)
|
||||
init[BTGreaterEqualStrategyNumber - 1] = 0;
|
||||
else
|
||||
init[BTGreaterStrategyNumber - 1] = 0;
|
||||
}
|
||||
|
||||
/* okay, reorder and count */
|
||||
for (j = BTMaxStrategyNumber; --j >= 0; )
|
||||
if (init[j])
|
||||
key[new_numberOfKeys++] = xform[j];
|
||||
|
||||
if ( attno == 1 )
|
||||
so->numberOfFirstKeys = new_numberOfKeys;
|
||||
|
||||
if ( i == numberOfKeys )
|
||||
break;
|
||||
|
||||
/* initialization for new attno */
|
||||
attno = cur->sk_attno;
|
||||
memset(xform, 0, nbytes);
|
||||
map = IndexStrategyGetStrategyMap(RelationGetIndexStrategy(relation),
|
||||
BTMaxStrategyNumber,
|
||||
attno);
|
||||
/* haven't looked at any strategies yet */
|
||||
for (j = 0; j <= BTMaxStrategyNumber; j++)
|
||||
init[j] = 0;
|
||||
}
|
||||
|
||||
for (j = BTMaxStrategyNumber; --j >= 0; )
|
||||
{
|
||||
if (cur->sk_procedure == map->entry[j].sk_procedure)
|
||||
break;
|
||||
break;
|
||||
}
|
||||
|
||||
/* have we seen one of these before? */
|
||||
if (init[j]) {
|
||||
if (init[j])
|
||||
{
|
||||
/* yup, use the appropriate value */
|
||||
test =
|
||||
(long) FMGR_PTR2(cur->sk_func, cur->sk_procedure,
|
||||
|
@ -132,97 +227,18 @@ _bt_orderkeys(Relation relation, uint16 *numberOfKeys, ScanKey key, uint16 *qual
|
|||
if (test)
|
||||
xform[j].sk_argument = cur->sk_argument;
|
||||
else if ( j == (BTEqualStrategyNumber - 1) )
|
||||
*qual_ok = 0; /* key == a && key == b, but a != b */
|
||||
} else {
|
||||
so->qual_ok = 0; /* key == a && key == b, but a != b */
|
||||
} else
|
||||
{
|
||||
/* nope, use this value */
|
||||
memmove(&xform[j], cur, sizeof(*cur));
|
||||
|
||||
init[j] = 1;
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
/* if = has been specified, no other key will be used */
|
||||
/*
|
||||
* XXX
|
||||
* But in case of key < 2 && key == 1 and so on
|
||||
* we have to set qual_ok to 0
|
||||
*/
|
||||
if (init[BTEqualStrategyNumber - 1]) {
|
||||
|
||||
ScanKeyData *eq, *chk;
|
||||
|
||||
eq = &xform[BTEqualStrategyNumber - 1];
|
||||
|
||||
for (j = BTMaxStrategyNumber; --j >= 0; )
|
||||
{
|
||||
if ( j == (BTEqualStrategyNumber - 1) || init[j] == 0 )
|
||||
continue;
|
||||
|
||||
chk = &xform[j];
|
||||
|
||||
test = (long) fmgr(chk->sk_procedure, eq->sk_argument, chk->sk_argument);
|
||||
|
||||
if (!test)
|
||||
*qual_ok = 0;
|
||||
}
|
||||
|
||||
init[BTLessStrategyNumber - 1] = 0;
|
||||
init[BTLessEqualStrategyNumber - 1] = 0;
|
||||
init[BTGreaterEqualStrategyNumber - 1] = 0;
|
||||
init[BTGreaterStrategyNumber - 1] = 0;
|
||||
}
|
||||
|
||||
/* only one of <, <= */
|
||||
if (init[BTLessStrategyNumber - 1]
|
||||
&& init[BTLessEqualStrategyNumber - 1]) {
|
||||
|
||||
ScanKeyData *lt, *le;
|
||||
|
||||
lt = &xform[BTLessStrategyNumber - 1];
|
||||
le = &xform[BTLessEqualStrategyNumber - 1];
|
||||
|
||||
/*
|
||||
* DO NOT use the cached function stuff here -- this is key
|
||||
* ordering, happens only when the user expresses a hokey
|
||||
* qualification, and gets executed only once, anyway. The
|
||||
* transform maps are hard-coded, and can't be initialized
|
||||
* in the correct way.
|
||||
*/
|
||||
|
||||
test = (long) fmgr(le->sk_procedure, lt->sk_argument, le->sk_argument);
|
||||
|
||||
if (test)
|
||||
init[BTLessEqualStrategyNumber - 1] = 0;
|
||||
else
|
||||
init[BTLessStrategyNumber - 1] = 0;
|
||||
}
|
||||
|
||||
/* only one of >, >= */
|
||||
if (init[BTGreaterStrategyNumber - 1]
|
||||
&& init[BTGreaterEqualStrategyNumber - 1]) {
|
||||
|
||||
ScanKeyData *gt, *ge;
|
||||
|
||||
gt = &xform[BTGreaterStrategyNumber - 1];
|
||||
ge = &xform[BTGreaterEqualStrategyNumber - 1];
|
||||
|
||||
/* see note above on function cache */
|
||||
test = (long) fmgr(ge->sk_procedure, gt->sk_argument, ge->sk_argument);
|
||||
|
||||
if (test)
|
||||
init[BTGreaterEqualStrategyNumber - 1] = 0;
|
||||
else
|
||||
init[BTGreaterStrategyNumber - 1] = 0;
|
||||
}
|
||||
|
||||
/* okay, reorder and count */
|
||||
j = 0;
|
||||
|
||||
for (i = BTMaxStrategyNumber; --i >= 0; )
|
||||
if (init[i])
|
||||
key[j++] = xform[i];
|
||||
|
||||
*numberOfKeys = j;
|
||||
so->numberOfKeys = new_numberOfKeys;
|
||||
|
||||
pfree(xform);
|
||||
}
|
||||
|
@ -230,9 +246,25 @@ _bt_orderkeys(Relation relation, uint16 *numberOfKeys, ScanKey key, uint16 *qual
|
|||
bool
|
||||
_bt_checkqual(IndexScanDesc scan, IndexTuple itup)
|
||||
{
|
||||
if (scan->numberOfKeys > 0)
|
||||
BTScanOpaque so;
|
||||
|
||||
so = (BTScanOpaque) scan->opaque;
|
||||
if (so->numberOfKeys > 0)
|
||||
return (index_keytest(itup, RelationGetTupleDescriptor(scan->relation),
|
||||
scan->numberOfKeys, scan->keyData));
|
||||
so->numberOfKeys, so->keyData));
|
||||
else
|
||||
return (true);
|
||||
}
|
||||
|
||||
bool
|
||||
_bt_checkforkeys(IndexScanDesc scan, IndexTuple itup, Size keysz)
|
||||
{
|
||||
BTScanOpaque so;
|
||||
|
||||
so = (BTScanOpaque) scan->opaque;
|
||||
if ( keysz > 0 && so->numberOfKeys >= keysz )
|
||||
return (index_keytest(itup, RelationGetTupleDescriptor(scan->relation),
|
||||
keysz, so->keyData));
|
||||
else
|
||||
return (true);
|
||||
}
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.6 1997/03/12 21:00:17 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.7 1997/03/18 18:39:40 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -53,8 +53,9 @@ static bool match_index_to_operand(int indexkey, Expr *operand,
|
|||
static List *match_index_orclause(Rel *rel, Rel *index, int indexkey,
|
||||
int xclass, List *or_clauses, List *other_matching_indices);
|
||||
static List *group_clauses_by_indexkey(Rel *rel, Rel *index,
|
||||
int *indexkeys, Oid *classes, List *clauseinfo_list,
|
||||
bool join);
|
||||
int *indexkeys, Oid *classes, List *clauseinfo_list);
|
||||
static List *group_clauses_by_ikey_for_joins(Rel *rel, Rel *index,
|
||||
int *indexkeys, Oid *classes, List *join_cinfo_list, List *restr_cinfo_list);
|
||||
static CInfo *match_clause_to_indexkey(Rel *rel, Rel *index, int indexkey,
|
||||
int xclass, CInfo *clauseInfo, bool join);
|
||||
static bool pred_test(List *predicate_list, List *clauseinfo_list,
|
||||
|
@ -63,7 +64,8 @@ static bool one_pred_test(Expr *predicate, List *clauseinfo_list);
|
|||
static bool one_pred_clause_expr_test(Expr *predicate, Node *clause);
|
||||
static bool one_pred_clause_test(Expr *predicate, Node *clause);
|
||||
static bool clause_pred_clause_test(Expr *predicate, Node *clause);
|
||||
static List *indexable_joinclauses(Rel *rel, Rel *index, List *joininfo_list);
|
||||
static List *indexable_joinclauses (Rel *rel, Rel *index,
|
||||
List *joininfo_list, List *clauseinfo_list);
|
||||
static List *index_innerjoin(Query *root, Rel *rel,
|
||||
List *clausegroup_list, Rel *index);
|
||||
static List *create_index_paths(Query *root, Rel *rel, Rel *index,
|
||||
|
@ -114,7 +116,6 @@ find_index_paths (Query *root,
|
|||
List *joinclausegroups = NIL;
|
||||
List *joinpaths = NIL;
|
||||
List *retval = NIL;
|
||||
extern List *add_index_paths();
|
||||
|
||||
if(indices == NIL)
|
||||
return(NULL);
|
||||
|
@ -160,8 +161,7 @@ find_index_paths (Query *root,
|
|||
index,
|
||||
index->indexkeys,
|
||||
index->classlist,
|
||||
clauseinfo_list,
|
||||
false);
|
||||
clauseinfo_list);
|
||||
|
||||
scanpaths = NIL;
|
||||
if (scanclausegroups != NIL)
|
||||
|
@ -178,7 +178,7 @@ find_index_paths (Query *root,
|
|||
* useful for a mergejoin, or if the index can possibly be
|
||||
* used for scanning the inner relation of a nestloop join.
|
||||
*/
|
||||
joinclausegroups = indexable_joinclauses(rel,index,joininfo_list);
|
||||
joinclausegroups = indexable_joinclauses(rel,index,joininfo_list, clauseinfo_list);
|
||||
joinpaths = NIL;
|
||||
|
||||
if (joinclausegroups != NIL)
|
||||
|
@ -375,10 +375,8 @@ match_index_orclause(Rel *rel,
|
|||
* (2) a list of join clauses between 'rel' and a fixed set of
|
||||
* relations,
|
||||
* depending on the value of 'join'.
|
||||
* 'startlist' is a list of those clause nodes that have matched the keys
|
||||
* that have already been checked.
|
||||
* 'join' is a flag indicating that the clauses being checked are join
|
||||
* clauses.
|
||||
*
|
||||
* NOTE: it works now for restriction clauses only. - vadim 03/18/97
|
||||
*
|
||||
* Returns all possible groups of clauses that will match (given that
|
||||
* one or more clauses can match any of the remaining keys).
|
||||
|
@ -391,48 +389,147 @@ group_clauses_by_indexkey(Rel *rel,
|
|||
Rel *index,
|
||||
int *indexkeys,
|
||||
Oid *classes,
|
||||
List *clauseinfo_list,
|
||||
bool join)
|
||||
List *clauseinfo_list)
|
||||
{
|
||||
List *curCinfo = NIL;
|
||||
CInfo *matched_clause = (CInfo*)NULL;
|
||||
List *clausegroup = NIL;
|
||||
|
||||
int curIndxKey;
|
||||
Oid curClass;
|
||||
|
||||
if (clauseinfo_list == NIL)
|
||||
return NIL;
|
||||
|
||||
foreach (curCinfo,clauseinfo_list) {
|
||||
CInfo *temp = (CInfo*)lfirst(curCinfo);
|
||||
int *curIndxKey = indexkeys;
|
||||
Oid *curClass = classes;
|
||||
while ( !DoneMatchingIndexKeys(indexkeys, index) )
|
||||
{
|
||||
List *tempgroup = NIL;
|
||||
|
||||
curIndxKey = indexkeys[0];
|
||||
curClass = classes[0];
|
||||
|
||||
foreach (curCinfo,clauseinfo_list)
|
||||
{
|
||||
CInfo *temp = (CInfo*)lfirst(curCinfo);
|
||||
|
||||
do {
|
||||
/*
|
||||
* If we can't find any matching clauses for the first of
|
||||
* the remaining keys, give up.
|
||||
*/
|
||||
matched_clause = match_clause_to_indexkey (rel,
|
||||
index,
|
||||
curIndxKey[0],
|
||||
curClass[0],
|
||||
curIndxKey,
|
||||
curClass,
|
||||
temp,
|
||||
join);
|
||||
false);
|
||||
if (!matched_clause)
|
||||
break;
|
||||
continue;
|
||||
|
||||
clausegroup = lcons(matched_clause, clausegroup);
|
||||
curIndxKey++;
|
||||
curClass++;
|
||||
tempgroup = lappend(tempgroup, matched_clause);
|
||||
}
|
||||
if ( tempgroup == NIL )
|
||||
break;
|
||||
|
||||
} while ( !DoneMatchingIndexKeys(curIndxKey, index) );
|
||||
clausegroup = nconc (clausegroup, tempgroup);
|
||||
|
||||
indexkeys++;
|
||||
classes++;
|
||||
|
||||
}
|
||||
|
||||
/* clausegroup holds all matched clauses ordered by indexkeys */
|
||||
|
||||
if (clausegroup != NIL)
|
||||
return(lcons(clausegroup, NIL));
|
||||
return NIL;
|
||||
}
|
||||
|
||||
/*
|
||||
* group-clauses-by-ikey-for-joins--
|
||||
* special edition of group-clauses-by-indexkey - will
|
||||
* match join & restriction clauses. See comment in indexable_joinclauses.
|
||||
* - vadim 03/18/97
|
||||
*
|
||||
*/
|
||||
static List *
|
||||
group_clauses_by_ikey_for_joins(Rel *rel,
|
||||
Rel *index,
|
||||
int *indexkeys,
|
||||
Oid *classes,
|
||||
List *join_cinfo_list,
|
||||
List *restr_cinfo_list)
|
||||
{
|
||||
List *curCinfo = NIL;
|
||||
CInfo *matched_clause = (CInfo*)NULL;
|
||||
List *clausegroup = NIL;
|
||||
int curIndxKey;
|
||||
Oid curClass;
|
||||
bool jfound = false;
|
||||
|
||||
if (join_cinfo_list == NIL)
|
||||
return NIL;
|
||||
|
||||
while ( !DoneMatchingIndexKeys(indexkeys, index) )
|
||||
{
|
||||
List *tempgroup = NIL;
|
||||
|
||||
curIndxKey = indexkeys[0];
|
||||
curClass = classes[0];
|
||||
|
||||
foreach (curCinfo,join_cinfo_list)
|
||||
{
|
||||
CInfo *temp = (CInfo*)lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey (rel,
|
||||
index,
|
||||
curIndxKey,
|
||||
curClass,
|
||||
temp,
|
||||
true);
|
||||
if (!matched_clause)
|
||||
continue;
|
||||
|
||||
tempgroup = lappend(tempgroup, matched_clause);
|
||||
jfound = true;
|
||||
}
|
||||
foreach (curCinfo,restr_cinfo_list)
|
||||
{
|
||||
CInfo *temp = (CInfo*)lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey (rel,
|
||||
index,
|
||||
curIndxKey,
|
||||
curClass,
|
||||
temp,
|
||||
false);
|
||||
if (!matched_clause)
|
||||
continue;
|
||||
|
||||
tempgroup = lappend(tempgroup, matched_clause);
|
||||
}
|
||||
if ( tempgroup == NIL )
|
||||
break;
|
||||
|
||||
clausegroup = nconc (clausegroup, tempgroup);
|
||||
|
||||
indexkeys++;
|
||||
classes++;
|
||||
|
||||
}
|
||||
|
||||
/* clausegroup holds all matched clauses ordered by indexkeys */
|
||||
|
||||
if (clausegroup != NIL)
|
||||
{
|
||||
/*
|
||||
* if no one join clause was matched then there ain't clauses
|
||||
* for joins at all.
|
||||
*/
|
||||
if ( !jfound )
|
||||
{
|
||||
freeList (clausegroup);
|
||||
return NIL;
|
||||
}
|
||||
return(lcons(clausegroup, NIL));
|
||||
}
|
||||
return NIL;
|
||||
}
|
||||
|
||||
/*
|
||||
* IndexScanableClause () MACRO
|
||||
*
|
||||
|
@ -482,6 +579,7 @@ match_clause_to_indexkey(Rel *rel,
|
|||
Expr *clause = clauseInfo->clause;
|
||||
Var *leftop, *rightop;
|
||||
Oid join_op = InvalidOid;
|
||||
Oid restrict_op = InvalidOid;
|
||||
bool isIndexable = false;
|
||||
|
||||
if (or_clause((Node*)clause) ||
|
||||
|
@ -495,91 +593,88 @@ match_clause_to_indexkey(Rel *rel,
|
|||
* (operator var/func constant) and (operator constant var/func)
|
||||
*/
|
||||
if (!join)
|
||||
{
|
||||
Oid restrict_op = InvalidOid;
|
||||
|
||||
/*
|
||||
* Check for standard s-argable clause
|
||||
*/
|
||||
{
|
||||
/*
|
||||
* Check for standard s-argable clause
|
||||
*/
|
||||
#ifdef INDEXSCAN_PATCH
|
||||
/* Handle also function parameters. DZ - 27-8-1996 */
|
||||
if ((rightop && IsA(rightop,Const)) ||
|
||||
if ((rightop && IsA(rightop,Const)) ||
|
||||
(rightop && IsA(rightop,Param)))
|
||||
#else
|
||||
if (rightop && IsA(rightop,Const))
|
||||
if (rightop && IsA(rightop,Const))
|
||||
#endif
|
||||
{
|
||||
restrict_op = ((Oper*)((Expr*)clause)->oper)->opno;
|
||||
isIndexable =
|
||||
( op_class(restrict_op, xclass, index->relam) &&
|
||||
{
|
||||
restrict_op = ((Oper*)((Expr*)clause)->oper)->opno;
|
||||
isIndexable =
|
||||
( op_class(restrict_op, xclass, index->relam) &&
|
||||
IndexScanableOperand(leftop,
|
||||
indexkey,
|
||||
rel,
|
||||
index) );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Must try to commute the clause to standard s-arg format.
|
||||
*/
|
||||
/*
|
||||
* Must try to commute the clause to standard s-arg format.
|
||||
*/
|
||||
#ifdef INDEXSCAN_PATCH
|
||||
/* ...And here... - vadim 01/22/97 */
|
||||
else if ((leftop && IsA(leftop,Const)) ||
|
||||
else if ((leftop && IsA(leftop,Const)) ||
|
||||
(leftop && IsA(leftop,Param)))
|
||||
#else
|
||||
else if (leftop && IsA(leftop,Const))
|
||||
else if (leftop && IsA(leftop,Const))
|
||||
#endif
|
||||
{
|
||||
restrict_op =
|
||||
get_commutator(((Oper*)((Expr*)clause)->oper)->opno);
|
||||
{
|
||||
restrict_op =
|
||||
get_commutator(((Oper*)((Expr*)clause)->oper)->opno);
|
||||
|
||||
if ( (restrict_op != InvalidOid) &&
|
||||
if ( (restrict_op != InvalidOid) &&
|
||||
op_class(restrict_op, xclass, index->relam) &&
|
||||
IndexScanableOperand(rightop,
|
||||
indexkey,rel,index) )
|
||||
{
|
||||
isIndexable = true;
|
||||
/*
|
||||
* In place list modification.
|
||||
* (op const var/func) -> (op var/func const)
|
||||
*/
|
||||
/* BUG! Old version:
|
||||
CommuteClause(clause, restrict_op);
|
||||
*/
|
||||
CommuteClause((Node*)clause);
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
isIndexable = true;
|
||||
/*
|
||||
* In place list modification.
|
||||
* (op const var/func) -> (op var/func const)
|
||||
*/
|
||||
CommuteClause((Node*)clause);
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Check for an indexable scan on one of the join relations.
|
||||
* clause is of the form (operator var/func var/func)
|
||||
*/
|
||||
else
|
||||
{
|
||||
if (rightop
|
||||
&& match_index_to_operand(indexkey,(Expr*)rightop,rel,index))
|
||||
{
|
||||
if (rightop
|
||||
&& match_index_to_operand(indexkey,(Expr*)rightop,rel,index)) {
|
||||
|
||||
join_op = get_commutator(((Oper*)((Expr*)clause)->oper)->opno);
|
||||
|
||||
} else if (leftop
|
||||
} else if (leftop
|
||||
&& match_index_to_operand(indexkey,
|
||||
(Expr*)leftop,rel,index)) {
|
||||
(Expr*)leftop,rel,index))
|
||||
{
|
||||
join_op = ((Oper*)((Expr*)clause)->oper)->opno;
|
||||
}
|
||||
|
||||
if ( join_op && op_class(join_op,xclass,index->relam) &&
|
||||
join_clause_p((Node*)clause))
|
||||
{
|
||||
isIndexable = true;
|
||||
|
||||
/*
|
||||
* If we're using the operand's commutator we must
|
||||
* commute the clause.
|
||||
*/
|
||||
if (join_op != ((Oper*)((Expr*)clause)->oper)->opno)
|
||||
CommuteClause((Node*)clause);
|
||||
}
|
||||
}
|
||||
|
||||
if ( join_op && op_class(join_op,xclass,index->relam) &&
|
||||
join_clause_p((Node*)clause))
|
||||
{
|
||||
isIndexable = true;
|
||||
|
||||
/*
|
||||
* If we're using the operand's commutator we must
|
||||
* commute the clause.
|
||||
*/
|
||||
if (join_op != ((Oper*)((Expr*)clause)->oper)->opno)
|
||||
CommuteClause((Node*)clause);
|
||||
}
|
||||
}
|
||||
|
||||
if (isIndexable)
|
||||
return(clauseInfo);
|
||||
|
||||
|
@ -955,10 +1050,15 @@ clause_pred_clause_test(Expr *predicate, Node *clause)
|
|||
* in the join clause as its outer join relation.
|
||||
*
|
||||
* Returns a list of these clause groups.
|
||||
*
|
||||
* Added: clauseinfo_list - list of restriction CInfos. It's to
|
||||
* support multi-column indices in joins and for cases
|
||||
* when a key is in both join & restriction clauses. - vadim 03/18/97
|
||||
*
|
||||
*/
|
||||
static List *
|
||||
indexable_joinclauses(Rel *rel, Rel *index, List *joininfo_list)
|
||||
indexable_joinclauses(Rel *rel, Rel *index,
|
||||
List *joininfo_list, List *clauseinfo_list)
|
||||
{
|
||||
JInfo *joininfo = (JInfo*)NULL;
|
||||
List *cg_list = NIL;
|
||||
|
@ -967,13 +1067,16 @@ indexable_joinclauses(Rel *rel, Rel *index, List *joininfo_list)
|
|||
|
||||
foreach(i,joininfo_list) {
|
||||
joininfo = (JInfo*)lfirst(i);
|
||||
|
||||
if ( joininfo->jinfoclauseinfo == NIL )
|
||||
continue;
|
||||
clausegroups =
|
||||
group_clauses_by_indexkey (rel,
|
||||
group_clauses_by_ikey_for_joins (rel,
|
||||
index,
|
||||
index->indexkeys,
|
||||
index->classlist,
|
||||
joininfo->jinfoclauseinfo,
|
||||
true);
|
||||
clauseinfo_list);
|
||||
|
||||
if (clausegroups != NIL) {
|
||||
List *clauses = lfirst(clausegroups);
|
||||
|
@ -1056,6 +1159,7 @@ index_innerjoin(Query *root, Rel *rel, List *clausegroup_list, Rel *index)
|
|||
pathnode->path.pathtype = T_IndexScan;
|
||||
pathnode->path.parent = rel;
|
||||
pathnode->indexid = index->relids;
|
||||
pathnode->indexkeys = index->indexkeys;
|
||||
pathnode->indexqual = clausegroup;
|
||||
|
||||
pathnode->path.joinid = ((CInfo*)lfirst(clausegroup))->cinfojoinid;
|
||||
|
@ -1130,7 +1234,7 @@ create_index_paths(Query *root,
|
|||
temp = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (!join || temp) { /* restriction, ordering scan */
|
||||
temp_path = create_index_path (root, rel,index,clausegroup,join);
|
||||
temp_node =
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.8 1997/03/12 21:05:56 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.9 1997/03/18 18:40:05 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -417,22 +417,35 @@ create_nestloop_node(JoinPath *best_path,
|
|||
NestLoop *join_node = (NestLoop*)NULL;
|
||||
|
||||
if (IsA(inner_node,IndexScan)) {
|
||||
/* An index is being used to reduce the number of tuples scanned in
|
||||
* the inner relation.
|
||||
* There will never be more than one index used in the inner
|
||||
* scan path, so we need only consider the first set of
|
||||
* qualifications in indxqual.
|
||||
/* An index is being used to reduce the number of tuples scanned in
|
||||
* the inner relation. There will never be more than one index used
|
||||
* in the inner scan path, so we need only consider the first set of
|
||||
* qualifications in indxqual.
|
||||
*
|
||||
* But there may be more than one clauses in this "first set"
|
||||
* in the case of multi-column indices. - vadim 03/18/97
|
||||
*/
|
||||
|
||||
List *inner_indxqual = lfirst(((IndexScan*)inner_node)->indxqual);
|
||||
List *inner_qual = (inner_indxqual == NULL)? NULL:lfirst(inner_indxqual);
|
||||
List *inner_qual;
|
||||
bool found = false;
|
||||
|
||||
foreach (inner_qual, inner_indxqual)
|
||||
{
|
||||
if ( !(qual_clause_p ((Node*)inner_qual)) )
|
||||
{
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* If we have in fact found a join index qualification, remove these
|
||||
* index clauses from the nestloop's join clauses and reset the
|
||||
* inner(index) scan's qualification so that the var nodes refer to
|
||||
* the proper outer join relation attributes.
|
||||
*/
|
||||
if (!(qual_clause_p((Node*)inner_qual))) {
|
||||
if ( found )
|
||||
{
|
||||
List *new_inner_qual = NIL;
|
||||
|
||||
clauses = set_difference(clauses,inner_indxqual);
|
||||
|
@ -613,7 +626,7 @@ fix_indxqual_references(Node *clause, Path *index_path)
|
|||
if (lfirsti(index_path->parent->relids) == ((Var*)clause)->varno) {
|
||||
int pos = 0;
|
||||
int varatt = ((Var*)clause)->varattno;
|
||||
int *indexkeys = index_path->parent->indexkeys;
|
||||
int *indexkeys = ((IndexPath*)index_path)->indexkeys;
|
||||
|
||||
if (indexkeys) {
|
||||
while (indexkeys[pos] != 0) {
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.2 1997/03/18 18:40:40 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -248,10 +248,11 @@ create_index_path(Query *root,
|
|||
|
||||
pathnode->path.pathtype = T_IndexScan;
|
||||
pathnode->path.parent = rel;
|
||||
pathnode->indexid = index->relids;
|
||||
|
||||
pathnode->path.p_ordering.ordtype = SORTOP_ORDER;
|
||||
pathnode->path.p_ordering.ord.sortop = index->ordering;
|
||||
|
||||
pathnode->indexid = index->relids;
|
||||
pathnode->indexkeys = index->indexkeys;
|
||||
pathnode->indexqual = NIL;
|
||||
|
||||
/* copy clauseinfo list into path for expensive function processing
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: nbtree.h,v 1.9 1997/02/22 10:08:27 vadim Exp $
|
||||
* $Id: nbtree.h,v 1.10 1997/03/18 18:41:16 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -68,6 +68,7 @@ typedef struct BTScanOpaqueData {
|
|||
Buffer btso_mrkbuf;
|
||||
uint16 qual_ok; /* 0 for quals like key == 1 && key > 2 */
|
||||
uint16 numberOfKeys; /* number of key attributes */
|
||||
uint16 numberOfFirstKeys; /* number of first key attributes */
|
||||
ScanKey keyData; /* key descriptor */
|
||||
} BTScanOpaqueData;
|
||||
|
||||
|
@ -270,9 +271,9 @@ extern bool _bt_invokestrat(Relation rel, AttrNumber attno,
|
|||
extern ScanKey _bt_mkscankey(Relation rel, IndexTuple itup);
|
||||
extern void _bt_freeskey(ScanKey skey);
|
||||
extern void _bt_freestack(BTStack stack);
|
||||
extern void _bt_orderkeys(Relation relation, uint16 *numberOfKeys,
|
||||
ScanKey key, uint16 *qual_ok);
|
||||
extern void _bt_orderkeys(Relation relation, BTScanOpaque so);
|
||||
extern bool _bt_checkqual(IndexScanDesc scan, IndexTuple itup);
|
||||
extern bool _bt_checkforkeys(IndexScanDesc scan, IndexTuple itup, Size keysz);
|
||||
extern BTItem _bt_formitem(IndexTuple itup);
|
||||
|
||||
/*
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: relation.h,v 1.3 1996/11/06 07:44:18 scrappy Exp $
|
||||
* $Id: relation.h,v 1.4 1997/03/18 18:41:37 scrappy Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -150,6 +150,7 @@ typedef struct IndexPath {
|
|||
Path path;
|
||||
List *indexid;
|
||||
List *indexqual;
|
||||
int *indexkeys; /* to transform heap attnos into index ones */
|
||||
} IndexPath;
|
||||
|
||||
typedef struct JoinPath {
|
||||
|
|
Loading…
Reference in New Issue