int strategy;
Oid lefttype;
Oid righttype;
- bool recheck;
Oid proc;
get_op_opfamily_properties(opno, opfamily,
&strategy,
&lefttype,
- &righttype,
- &recheck);
+ &righttype);
proc = get_opfamily_proc(opfamily,
lefttype,
righttype,
ExecIndexBuildScanKeys((PlanState *) indexstate,
indexstate->biss_RelationDesc,
node->indexqual,
- node->indexstrategy,
- node->indexsubtype,
&indexstate->biss_ScanKeys,
&indexstate->biss_NumScanKeys,
&indexstate->biss_RuntimeKeys,
ExecIndexBuildScanKeys((PlanState *) indexstate,
indexstate->iss_RelationDesc,
node->indexqual,
- node->indexstrategy,
- node->indexsubtype,
&indexstate->iss_ScanKeys,
&indexstate->iss_NumScanKeys,
&indexstate->iss_RuntimeKeys,
* planstate: executor state node we are working for
* index: the index we are building scan keys for
* quals: indexquals expressions
- * strategies: associated operator strategy numbers
- * subtypes: associated operator subtype OIDs
- *
- * (Any elements of the strategies and subtypes lists that correspond to
- * RowCompareExpr quals are not used here; instead we look up the info
- * afresh.)
*
* Output params are:
*
* ScalarArrayOpExpr quals are not supported.
*/
void
-ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
- List *quals, List *strategies, List *subtypes,
+ExecIndexBuildScanKeys(PlanState *planstate, Relation index, List *quals,
ScanKey *scanKeys, int *numScanKeys,
IndexRuntimeKeyInfo **runtimeKeys, int *numRuntimeKeys,
IndexArrayKeyInfo **arrayKeys, int *numArrayKeys)
{
ListCell *qual_cell;
- ListCell *strategy_cell;
- ListCell *subtype_cell;
ScanKey scan_keys;
IndexRuntimeKeyInfo *runtime_keys;
IndexArrayKeyInfo *array_keys;
extra_scan_keys = n_scan_keys;
/*
- * for each opclause in the given qual, convert each qual's opclause into
+ * for each opclause in the given qual, convert the opclause into
* a single scan key
*/
- qual_cell = list_head(quals);
- strategy_cell = list_head(strategies);
- subtype_cell = list_head(subtypes);
-
- for (j = 0; j < n_scan_keys; j++)
+ j = 0;
+ foreach(qual_cell, quals)
{
- ScanKey this_scan_key = &scan_keys[j];
- Expr *clause; /* one clause of index qual */
+ Expr *clause = (Expr *) lfirst(qual_cell);
+ ScanKey this_scan_key = &scan_keys[j++];
+ Oid opno; /* operator's OID */
RegProcedure opfuncid; /* operator proc id used in scan */
- StrategyNumber strategy; /* op's strategy number */
- Oid subtype; /* op's strategy subtype */
+ Oid opfamily; /* opfamily of index column */
+ int op_strategy; /* operator's strategy number */
+ Oid op_lefttype; /* operator's declared input types */
+ Oid op_righttype;
Expr *leftop; /* expr on lhs of operator */
Expr *rightop; /* expr on rhs ... */
AttrNumber varattno; /* att number used in scan */
- /*
- * extract clause information from the qualification
- */
- clause = (Expr *) lfirst(qual_cell);
- qual_cell = lnext(qual_cell);
- strategy = lfirst_int(strategy_cell);
- strategy_cell = lnext(strategy_cell);
- subtype = lfirst_oid(subtype_cell);
- subtype_cell = lnext(subtype_cell);
-
if (IsA(clause, OpExpr))
{
/* indexkey op const or indexkey op expression */
int flags = 0;
Datum scanvalue;
+ opno = ((OpExpr *) clause)->opno;
opfuncid = ((OpExpr *) clause)->opfuncid;
/*
elog(ERROR, "indexqual doesn't have key on left side");
varattno = ((Var *) leftop)->varattno;
+ if (varattno < 1 || varattno > index->rd_index->indnatts)
+ elog(ERROR, "bogus index qualification");
+
+ /*
+ * We have to look up the operator's strategy number. This
+ * provides a cross-check that the operator does match the index.
+ */
+ opfamily = index->rd_opfamily[varattno - 1];
+
+ get_op_opfamily_properties(opno, opfamily,
+ &op_strategy,
+ &op_lefttype,
+ &op_righttype);
/*
* rightop is the constant or variable comparison value
ScanKeyEntryInitialize(this_scan_key,
flags,
varattno, /* attribute number to scan */
- strategy, /* op's strategy */
- subtype, /* strategy subtype */
+ op_strategy, /* op's strategy */
+ op_righttype, /* strategy subtype */
opfuncid, /* reg proc to use */
scanvalue); /* constant */
}
ScanKey this_sub_key = &scan_keys[extra_scan_keys];
int flags = SK_ROW_MEMBER;
Datum scanvalue;
- Oid opno;
- Oid opfamily;
- int op_strategy;
- Oid op_lefttype;
- Oid op_righttype;
- bool op_recheck;
/*
* leftop should be the index key Var, possibly relabeled
get_op_opfamily_properties(opno, opfamily,
&op_strategy,
&op_lefttype,
- &op_righttype,
- &op_recheck);
+ &op_righttype);
if (op_strategy != rc->rctype)
elog(ERROR, "RowCompare index qualification contains wrong operator");
ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
Assert(saop->useOr);
+ opno = saop->opno;
opfuncid = saop->opfuncid;
/*
elog(ERROR, "indexqual doesn't have key on left side");
varattno = ((Var *) leftop)->varattno;
+ if (varattno < 1 || varattno > index->rd_index->indnatts)
+ elog(ERROR, "bogus index qualification");
+
+ /*
+ * We have to look up the operator's strategy number. This
+ * provides a cross-check that the operator does match the index.
+ */
+ opfamily = index->rd_opfamily[varattno - 1];
+
+ get_op_opfamily_properties(opno, opfamily,
+ &op_strategy,
+ &op_lefttype,
+ &op_righttype);
/*
* rightop is the constant or variable array value
ScanKeyEntryInitialize(this_scan_key,
0, /* flags */
varattno, /* attribute number to scan */
- strategy, /* op's strategy */
- subtype, /* strategy subtype */
+ op_strategy, /* op's strategy */
+ op_righttype, /* strategy subtype */
opfuncid, /* reg proc to use */
(Datum) 0); /* constant */
}
ScanKeyEntryInitialize(this_scan_key,
SK_ISNULL | SK_SEARCHNULL,
varattno, /* attribute number to scan */
- strategy, /* op's strategy */
- subtype, /* strategy subtype */
+ InvalidStrategy, /* no strategy */
+ InvalidOid, /* no strategy subtype */
InvalidOid, /* no reg proc for this */
(Datum) 0); /* constant */
}
int op_strategy;
Oid op_lefttype;
Oid op_righttype;
- bool op_recheck;
RegProcedure cmpproc;
AclResult aclresult;
get_op_opfamily_properties(qual->opno, opfamily,
&op_strategy,
&op_lefttype,
- &op_righttype,
- &op_recheck);
+ &op_righttype);
if (op_strategy != BTEqualStrategyNumber) /* should not happen */
elog(ERROR, "cannot merge using non-equality operator %u",
qual->opno);
- Assert(!op_recheck); /* never true for btree */
/* And get the matching support procedure (comparison function) */
cmpproc = get_opfamily_proc(opfamily,
COPY_SCALAR_FIELD(indexid);
COPY_NODE_FIELD(indexqual);
COPY_NODE_FIELD(indexqualorig);
- COPY_NODE_FIELD(indexstrategy);
- COPY_NODE_FIELD(indexsubtype);
COPY_SCALAR_FIELD(indexorderdir);
return newnode;
COPY_SCALAR_FIELD(indexid);
COPY_NODE_FIELD(indexqual);
COPY_NODE_FIELD(indexqualorig);
- COPY_NODE_FIELD(indexstrategy);
- COPY_NODE_FIELD(indexsubtype);
return newnode;
}
WRITE_OID_FIELD(indexid);
WRITE_NODE_FIELD(indexqual);
WRITE_NODE_FIELD(indexqualorig);
- WRITE_NODE_FIELD(indexstrategy);
- WRITE_NODE_FIELD(indexsubtype);
WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
}
WRITE_OID_FIELD(indexid);
WRITE_NODE_FIELD(indexqual);
WRITE_NODE_FIELD(indexqualorig);
- WRITE_NODE_FIELD(indexstrategy);
- WRITE_NODE_FIELD(indexsubtype);
}
static void
int op_strategy;
Oid op_lefttype;
Oid op_righttype;
- bool op_recheck;
int matching_cols;
Oid expr_op;
List *opfamilies;
get_op_opfamily_properties(expr_op, index->opfamily[indexcol],
&op_strategy,
&op_lefttype,
- &op_righttype,
- &op_recheck);
+ &op_righttype);
/* Build lists of the opfamilies and operator datatypes in case needed */
opfamilies = list_make1_oid(index->opfamily[indexcol]);
lefttypes = list_make1_oid(op_lefttype);
get_op_opfamily_properties(expr_op, index->opfamily[i],
&op_strategy,
&op_lefttype,
- &op_righttype,
- &op_recheck);
+ &op_righttype);
opfamilies = lappend_oid(opfamilies, index->opfamily[i]);
lefttypes = lappend_oid(lefttypes, op_lefttype);
righttypes = lappend_oid(righttypes, op_righttype);
Plan *outer_plan, Plan *inner_plan);
static HashJoin *create_hashjoin_plan(PlannerInfo *root, HashPath *best_path,
Plan *outer_plan, Plan *inner_plan);
-static void fix_indexqual_references(List *indexquals, IndexPath *index_path,
- List **fixed_indexquals,
- List **indexstrategy,
- List **indexsubtype);
-static Node *fix_indexqual_operand(Node *node, IndexOptInfo *index,
- Oid *opfamily);
+static List *fix_indexqual_references(List *indexquals, IndexPath *index_path);
+static Node *fix_indexqual_operand(Node *node, IndexOptInfo *index);
static List *get_switched_clauses(List *clauses, Relids outerrelids);
static List *order_qual_clauses(PlannerInfo *root, List *clauses);
static void copy_path_costsize(Plan *dest, Path *src);
static SeqScan *make_seqscan(List *qptlist, List *qpqual, Index scanrelid);
static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
Oid indexid, List *indexqual, List *indexqualorig,
- List *indexstrategy, List *indexsubtype,
ScanDirection indexscandir);
static BitmapIndexScan *make_bitmap_indexscan(Index scanrelid, Oid indexid,
List *indexqual,
- List *indexqualorig,
- List *indexstrategy,
- List *indexsubtype);
+ List *indexqualorig);
static BitmapHeapScan *make_bitmap_heapscan(List *qptlist,
List *qpqual,
Plan *lefttree,
List *qpqual;
List *stripped_indexquals;
List *fixed_indexquals;
- List *indexstrategy;
- List *indexsubtype;
ListCell *l;
IndexScan *scan_plan;
/*
* The executor needs a copy with the indexkey on the left of each clause
- * and with index attr numbers substituted for table ones. This pass also
- * gets strategy info.
+ * and with index attr numbers substituted for table ones.
*/
- fix_indexqual_references(indexquals, best_path,
- &fixed_indexquals,
- &indexstrategy,
- &indexsubtype);
+ fixed_indexquals = fix_indexqual_references(indexquals, best_path);
/*
* If this is an innerjoin scan, the indexclauses will contain join
indexoid,
fixed_indexquals,
stripped_indexquals,
- indexstrategy,
- indexsubtype,
best_path->indexscandir);
copy_path_costsize(&scan_plan->scan.plan, &best_path->path);
plan = (Plan *) make_bitmap_indexscan(iscan->scan.scanrelid,
iscan->indexid,
iscan->indexqual,
- iscan->indexqualorig,
- iscan->indexstrategy,
- iscan->indexsubtype);
+ iscan->indexqualorig);
plan->startup_cost = 0.0;
plan->total_cost = ipath->indextotalcost;
plan->plan_rows =
* Adjust indexqual clauses to the form the executor's indexqual
* machinery needs.
*
- * We have four tasks here:
+ * We have three tasks here:
* * Remove RestrictInfo nodes from the input clauses.
* * Index keys must be represented by Var nodes with varattno set to the
* index's attribute number, not the attribute number in the original rel.
* * If the index key is on the right, commute the clause to put it on the
* left.
- * * We must construct lists of operator strategy numbers and subtypes
- * for the top-level operators of each index clause.
*
- * fixed_indexquals receives a modified copy of the indexquals list --- the
+ * The result is a modified copy of the indexquals list --- the
* original is not changed. Note also that the copy shares no substructure
* with the original; this is needed in case there is a subplan in it (we need
* two separate copies of the subplan tree, or things will go awry).
- *
- * indexstrategy receives an integer list of strategy numbers.
- * indexsubtype receives an OID list of strategy subtypes.
*/
-static void
-fix_indexqual_references(List *indexquals, IndexPath *index_path,
- List **fixed_indexquals,
- List **indexstrategy,
- List **indexsubtype)
+static List *
+fix_indexqual_references(List *indexquals, IndexPath *index_path)
{
IndexOptInfo *index = index_path->indexinfo;
+ List *fixed_indexquals;
ListCell *l;
- *fixed_indexquals = NIL;
- *indexstrategy = NIL;
- *indexsubtype = NIL;
+ fixed_indexquals = NIL;
/*
* For each qual clause, commute if needed to put the indexkey operand on
* the left, and then fix its varattno. (We do not need to change the
- * other side of the clause.) Then determine the operator's strategy
- * number and subtype number.
+ * other side of the clause.)
*/
foreach(l, indexquals)
{
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
Expr *clause;
- Oid clause_op;
- Oid opfamily;
- int stratno;
- Oid stratlefttype;
- Oid stratrighttype;
- bool is_null_op = false;
Assert(IsA(rinfo, RestrictInfo));
CommuteOpExpr(op);
/*
- * Now, determine which index attribute this is, change the
- * indexkey operand as needed, and get the index opfamily.
+ * Now, determine which index attribute this is and change the
+ * indexkey operand as needed.
*/
linitial(op->args) = fix_indexqual_operand(linitial(op->args),
- index,
- &opfamily);
- clause_op = op->opno;
+ index);
}
else if (IsA(clause, RowCompareExpr))
{
/*
* For each column in the row comparison, determine which index
* attribute this is and change the indexkey operand as needed.
- *
- * Save the index opfamily for only the first column. We will
- * return the operator and opfamily info for just the first column
- * of the row comparison; the executor will have to look up the
- * rest if it needs them.
*/
foreach(lc, rc->largs)
{
- Oid tmp_opfamily;
-
lfirst(lc) = fix_indexqual_operand(lfirst(lc),
- index,
- &tmp_opfamily);
- if (lc == list_head(rc->largs))
- opfamily = tmp_opfamily;
+ index);
}
- clause_op = linitial_oid(rc->opnos);
}
else if (IsA(clause, ScalarArrayOpExpr))
{
/* Never need to commute... */
/*
- * Now, determine which index attribute this is, change the
- * indexkey operand as needed, and get the index opfamily.
+ * Determine which index attribute this is and change the
+ * indexkey operand as needed.
*/
linitial(saop->args) = fix_indexqual_operand(linitial(saop->args),
- index,
- &opfamily);
- clause_op = saop->opno;
+ index);
}
else if (IsA(clause, NullTest))
{
Assert(nt->nulltesttype == IS_NULL);
nt->arg = (Expr *) fix_indexqual_operand((Node *) nt->arg,
- index,
- &opfamily);
- is_null_op = true;
- clause_op = InvalidOid; /* keep compiler quiet */
+ index);
}
else
- {
elog(ERROR, "unsupported indexqual type: %d",
(int) nodeTag(clause));
- continue; /* keep compiler quiet */
- }
- *fixed_indexquals = lappend(*fixed_indexquals, clause);
-
- if (is_null_op)
- {
- /* IS NULL doesn't have a clause_op */
- stratno = InvalidStrategy;
- stratrighttype = InvalidOid;
- }
- else
- {
- /*
- * Look up the (possibly commuted) operator in the operator family
- * to get its strategy number and the recheck indicator. This also
- * double-checks that we found an operator matching the index.
- */
- bool recheck;
-
- get_op_opfamily_properties(clause_op, opfamily,
- &stratno,
- &stratlefttype,
- &stratrighttype,
- &recheck);
- }
-
- *indexstrategy = lappend_int(*indexstrategy, stratno);
- *indexsubtype = lappend_oid(*indexsubtype, stratrighttype);
+ fixed_indexquals = lappend(fixed_indexquals, clause);
}
+
+ return fixed_indexquals;
}
static Node *
-fix_indexqual_operand(Node *node, IndexOptInfo *index, Oid *opfamily)
+fix_indexqual_operand(Node *node, IndexOptInfo *index)
{
/*
* We represent index keys by Var nodes having the varno of the base table
{
result = (Var *) copyObject(node);
result->varattno = pos + 1;
- /* return the correct opfamily, too */
- *opfamily = index->opfamily[pos];
return (Node *) result;
}
}
result = makeVar(index->rel->relid, pos + 1,
exprType(lfirst(indexpr_item)), -1,
0);
- /* return the correct opfamily, too */
- *opfamily = index->opfamily[pos];
return (Node *) result;
}
indexpr_item = lnext(indexpr_item);
/* Ooops... */
elog(ERROR, "node is not an index attribute");
- *opfamily = InvalidOid; /* keep compiler quiet */
- return NULL;
+ return NULL; /* keep compiler quiet */
}
/*
Oid indexid,
List *indexqual,
List *indexqualorig,
- List *indexstrategy,
- List *indexsubtype,
ScanDirection indexscandir)
{
IndexScan *node = makeNode(IndexScan);
node->indexid = indexid;
node->indexqual = indexqual;
node->indexqualorig = indexqualorig;
- node->indexstrategy = indexstrategy;
- node->indexsubtype = indexsubtype;
node->indexorderdir = indexscandir;
return node;
make_bitmap_indexscan(Index scanrelid,
Oid indexid,
List *indexqual,
- List *indexqualorig,
- List *indexstrategy,
- List *indexsubtype)
+ List *indexqualorig)
{
BitmapIndexScan *node = makeNode(BitmapIndexScan);
Plan *plan = &node->scan.plan;
node->indexid = indexid;
node->indexqual = indexqual;
node->indexqualorig = indexqualorig;
- node->indexstrategy = indexstrategy;
- node->indexsubtype = indexsubtype;
return node;
}
int op_strategy;
Oid op_lefttype;
Oid op_righttype;
- bool op_recheck;
Oid opno,
lsortop,
rsortop,
get_op_opfamily_properties(opno, opfamily,
&op_strategy,
&op_lefttype,
- &op_righttype,
- &op_recheck);
+ &op_righttype);
Assert(op_strategy == BTEqualStrategyNumber);
- Assert(!op_recheck);
/*
* Look up the various operators we need. If we don't find them all, it
/*
* get_op_opfamily_properties
*
- * Get the operator's strategy number, input types, and recheck (lossy)
- * flag within the specified opfamily.
+ * Get the operator's strategy number and declared input data types
+ * within the specified opfamily.
*
* Caller should already have verified that opno is a member of opfamily,
* therefore we raise an error if the tuple is not found.
get_op_opfamily_properties(Oid opno, Oid opfamily,
int *strategy,
Oid *lefttype,
- Oid *righttype,
- bool *recheck)
+ Oid *righttype)
{
HeapTuple tp;
Form_pg_amop amop_tup;
*strategy = amop_tup->amopstrategy;
*lefttype = amop_tup->amoplefttype;
*righttype = amop_tup->amoprighttype;
- *recheck = amop_tup->amopreqcheck;
ReleaseSysCache(tp);
}
/* routines exported to share code with nodeBitmapIndexscan.c */
extern void ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
- List *quals, List *strategies, List *subtypes,
- ScanKey *scanKeys, int *numScanKeys,
+ List *quals, ScanKey *scanKeys, int *numScanKeys,
IndexRuntimeKeyInfo **runtimeKeys, int *numRuntimeKeys,
IndexArrayKeyInfo **arrayKeys, int *numArrayKeys);
extern void ExecIndexEvalRuntimeKeys(ExprContext *econtext,
* table). This is a bit hokey ... would be cleaner to use a special-purpose
* node type that could not be mistaken for a regular Var. But it will do
* for now.
- *
- * indexstrategy and indexsubtype are lists corresponding one-to-one with
- * indexqual; they give information about the indexable operators that appear
- * at the top of each indexqual.
* ----------------
*/
typedef struct IndexScan
Oid indexid; /* OID of index to scan */
List *indexqual; /* list of index quals (OpExprs) */
List *indexqualorig; /* the same in original form */
- List *indexstrategy; /* integer list of strategy numbers */
- List *indexsubtype; /* OID list of strategy subtypes */
ScanDirection indexorderdir; /* forward or backward or don't care */
} IndexScan;
Oid indexid; /* OID of index to scan */
List *indexqual; /* list of index quals (OpExprs) */
List *indexqualorig; /* the same in original form */
- List *indexstrategy; /* integer list of strategy numbers */
- List *indexsubtype; /* OID list of strategy subtypes */
} BitmapIndexScan;
/* ----------------
extern void get_op_opfamily_properties(Oid opno, Oid opfamily,
int *strategy,
Oid *lefttype,
- Oid *righttype,
- bool *recheck);
+ Oid *righttype);
extern Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype,
int16 strategy);
extern bool get_ordering_op_properties(Oid opno,
projects / users / simon / postgres.git / commitdiff