* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.18 2002/12/12 15:49:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.19 2003/01/10 21:08:07 tgl Exp $
*
*-------------------------------------------------------------------------
*/
&context->addrs);
/* fall through to examine arguments */
}
+ if (IsA(node, SubLink))
+ {
+ SubLink *sublink = (SubLink *) node;
+ List *opid;
+
+ foreach(opid, sublink->operOids)
+ {
+ add_object_address(OCLASS_OPERATOR, (Oid) lfirsti(opid), 0,
+ &context->addrs);
+ }
+ /* fall through to examine arguments */
+ }
if (is_subplan(node))
{
/* Extra work needed here if we ever need this case */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.121 2002/12/15 16:17:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.122 2003/01/10 21:08:07 tgl Exp $
*
*-------------------------------------------------------------------------
*/
sstate->sub_estate = NULL;
sstate->planstate = NULL;
- sstate->oper = (List *)
- ExecInitExpr((Expr *) subplan->oper, parent);
+ sstate->exprs = (List *)
+ ExecInitExpr((Expr *) subplan->exprs, parent);
sstate->args = (List *)
ExecInitExpr((Expr *) subplan->args, parent);
sstate->sub_estate = NULL;
sstate->planstate = NULL;
- sstate->oper = (List *) ExecInitExpr((Expr *) node->oper, parent);
+ sstate->exprs = (List *) ExecInitExpr((Expr *) node->exprs, parent);
sstate->args = (List *) ExecInitExpr((Expr *) node->args, parent);
sstate->xprstate.expr = (Expr *) node;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.41 2003/01/09 20:50:50 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.42 2003/01/10 21:08:08 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Datum rowresult = BoolGetDatum(!useOr);
bool rownull = false;
int col = 1;
+ List *plst;
if (subLinkType == EXISTS_SUBLINK)
{
* For ALL, ANY, and MULTIEXPR sublinks, iterate over combining
* operators for columns of tuple.
*/
- foreach(lst, node->oper)
+ plst = subplan->paramIds;
+ foreach(lst, node->exprs)
{
ExprState *exprstate = (ExprState *) lfirst(lst);
- OpExpr *expr = (OpExpr *) exprstate->expr;
- Param *prm = lsecond(expr->args);
+ int paramid = lfirsti(plst);
ParamExecData *prmdata;
Datum expresult;
bool expnull;
/*
- * The righthand side of the expression should be either a
- * Param or a function call or RelabelType node taking a Param
- * as arg (these nodes represent run-time type coercions
- * inserted by the parser to get to the input type needed by
- * the operator). Find the Param node and insert the actual
- * righthand-side value into the param's econtext slot.
- *
- * XXX possible improvement: could make a list of the ParamIDs
- * at startup time, instead of repeating this check at each row.
+ * Load up the Param representing this column of the sub-select.
*/
- if (!IsA(prm, Param))
- {
- switch (nodeTag(prm))
- {
- case T_FuncExpr:
- prm = lfirst(((FuncExpr *) prm)->args);
- break;
- case T_RelabelType:
- prm = (Param *) (((RelabelType *) prm)->arg);
- break;
- default:
- /* will fail below */
- break;
- }
- if (!IsA(prm, Param))
- elog(ERROR, "ExecSubPlan: failed to find placeholder for subplan result");
- }
- Assert(prm->paramkind == PARAM_EXEC);
- prmdata = &(econtext->ecxt_param_exec_vals[prm->paramid]);
+ prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
Assert(prmdata->execPlan == NULL);
prmdata->value = heap_getattr(tup, col, tdesc,
&(prmdata->isnull));
break; /* needn't look at any more columns */
}
}
+
+ plst = lnext(plst);
col++;
}
*/
node->needShutdown = false;
node->curTuple = NULL;
+ node->hashtable = NULL;
+ node->hashnulls = NULL;
/*
* create an EState for the subplan
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.234 2003/01/09 20:50:50 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.235 2003/01/10 21:08:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
SubLink *newnode = makeNode(SubLink);
COPY_SCALAR_FIELD(subLinkType);
- COPY_SCALAR_FIELD(operIsEquals);
COPY_SCALAR_FIELD(useOr);
COPY_NODE_FIELD(lefthand);
- COPY_NODE_FIELD(oper);
+ COPY_NODE_FIELD(operName);
+ COPY_INTLIST_FIELD(operOids);
COPY_NODE_FIELD(subselect);
return newnode;
COPY_SCALAR_FIELD(subLinkType);
COPY_SCALAR_FIELD(useOr);
- COPY_NODE_FIELD(oper);
+ COPY_NODE_FIELD(exprs);
+ COPY_INTLIST_FIELD(paramIds);
COPY_NODE_FIELD(plan);
COPY_SCALAR_FIELD(plan_id);
COPY_NODE_FIELD(rtable);
+ COPY_SCALAR_FIELD(useHashTable);
+ COPY_SCALAR_FIELD(unknownEqFalse);
COPY_INTLIST_FIELD(setParam);
COPY_INTLIST_FIELD(parParam);
COPY_NODE_FIELD(args);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.178 2003/01/09 20:50:50 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.179 2003/01/10 21:08:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
_equalSubLink(SubLink *a, SubLink *b)
{
COMPARE_SCALAR_FIELD(subLinkType);
- COMPARE_SCALAR_FIELD(operIsEquals);
COMPARE_SCALAR_FIELD(useOr);
COMPARE_NODE_FIELD(lefthand);
- COMPARE_NODE_FIELD(oper);
+ COMPARE_NODE_FIELD(operName);
+ COMPARE_INTLIST_FIELD(operOids);
COMPARE_NODE_FIELD(subselect);
return true;
{
COMPARE_SCALAR_FIELD(subLinkType);
COMPARE_SCALAR_FIELD(useOr);
- COMPARE_NODE_FIELD(oper);
+ COMPARE_NODE_FIELD(exprs);
+ COMPARE_INTLIST_FIELD(paramIds);
/* should compare plans, but have to settle for comparing plan IDs */
COMPARE_SCALAR_FIELD(plan_id);
COMPARE_NODE_FIELD(rtable);
+ COMPARE_SCALAR_FIELD(useHashTable);
+ COMPARE_SCALAR_FIELD(unknownEqFalse);
COMPARE_INTLIST_FIELD(setParam);
COMPARE_INTLIST_FIELD(parParam);
COMPARE_NODE_FIELD(args);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.191 2003/01/09 20:50:50 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.192 2003/01/10 21:08:11 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
WRITE_NODE_TYPE("SUBLINK");
WRITE_ENUM_FIELD(subLinkType, SubLinkType);
- WRITE_BOOL_FIELD(operIsEquals);
WRITE_BOOL_FIELD(useOr);
WRITE_NODE_FIELD(lefthand);
- WRITE_NODE_FIELD(oper);
+ WRITE_NODE_FIELD(operName);
+ WRITE_INTLIST_FIELD(operOids);
WRITE_NODE_FIELD(subselect);
}
WRITE_ENUM_FIELD(subLinkType, SubLinkType);
WRITE_BOOL_FIELD(useOr);
- WRITE_NODE_FIELD(oper);
+ WRITE_NODE_FIELD(exprs);
+ WRITE_INTLIST_FIELD(paramIds);
WRITE_NODE_FIELD(plan);
WRITE_INT_FIELD(plan_id);
WRITE_NODE_FIELD(rtable);
+ WRITE_BOOL_FIELD(useHashTable);
+ WRITE_BOOL_FIELD(unknownEqFalse);
WRITE_INTLIST_FIELD(setParam);
WRITE_INTLIST_FIELD(parParam);
WRITE_NODE_FIELD(args);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.145 2003/01/09 20:50:51 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.146 2003/01/10 21:08:11 tgl Exp $
*
* NOTES
* Path and Plan nodes do not have any readfuncs support, because we
READ_LOCALS(SubLink);
READ_ENUM_FIELD(subLinkType, SubLinkType);
- READ_BOOL_FIELD(operIsEquals);
READ_BOOL_FIELD(useOr);
READ_NODE_FIELD(lefthand);
- READ_NODE_FIELD(oper);
+ READ_NODE_FIELD(operName);
+ READ_INTLIST_FIELD(operOids);
READ_NODE_FIELD(subselect);
READ_DONE();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.86 2002/12/14 00:17:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.87 2003/01/10 21:08:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static void fix_expr_references(Plan *plan, Node *node);
static bool fix_expr_references_walker(Node *node, void *context);
+static void mark_qual_expressions(List *quals);
static void set_join_references(Join *join, List *rtable);
static void set_uppernode_references(Plan *plan, Index subvarno);
static Node *join_references_mutator(Node *node,
case T_SeqScan:
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
break;
case T_IndexScan:
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
fix_expr_references(plan,
(Node *) ((IndexScan *) plan)->indxqual);
fix_expr_references(plan,
case T_TidScan:
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
fix_expr_references(plan,
(Node *) ((TidScan *) plan)->tideval);
break;
*/
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
/* Recurse into subplan too */
rte = rt_fetch(((SubqueryScan *) plan)->scan.scanrelid,
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
rte = rt_fetch(((FunctionScan *) plan)->scan.scanrelid,
rtable);
Assert(rte->rtekind == RTE_FUNCTION);
set_join_references((Join *) plan, rtable);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
fix_expr_references(plan, (Node *) ((Join *) plan)->joinqual);
+ mark_qual_expressions(((Join *) plan)->joinqual);
break;
case T_MergeJoin:
set_join_references((Join *) plan, rtable);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
fix_expr_references(plan, (Node *) ((Join *) plan)->joinqual);
+ mark_qual_expressions(((Join *) plan)->joinqual);
fix_expr_references(plan,
(Node *) ((MergeJoin *) plan)->mergeclauses);
break;
set_join_references((Join *) plan, rtable);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
fix_expr_references(plan, (Node *) ((Join *) plan)->joinqual);
+ mark_qual_expressions(((Join *) plan)->joinqual);
fix_expr_references(plan,
(Node *) ((HashJoin *) plan)->hashclauses);
break;
set_uppernode_references(plan, (Index) 0);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
break;
case T_Result:
set_uppernode_references(plan, (Index) OUTER);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
+ mark_qual_expressions(plan->qual);
fix_expr_references(plan, ((Result *) plan)->resconstantqual);
+ mark_qual_expressions((List *) ((Result *) plan)->resconstantqual);
break;
case T_Append:
return expression_tree_walker(node, fix_expr_references_walker, context);
}
+/*
+ * mark_qual_expressions
+ * Do final cleanup on qualifier expressions (not targetlists!)
+ *
+ * SubPlans appearing at the top level of a qual expression are marked
+ * to indicate that they need not distinguish UNKNOWN (null) from FALSE
+ * results; this can save processing time in some cases.
+ */
+static void
+mark_qual_expressions(List *quals)
+{
+ List *qual;
+
+ foreach(qual, quals)
+ {
+ Node *node = lfirst(qual);
+
+ if (IsA(node, SubPlan))
+ ((SubPlan *) node)->unknownEqFalse = true;
+ }
+}
+
/*
* set_join_references
* Modifies the target list of a join node to reference its subplans,
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.62 2003/01/09 20:50:51 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.63 2003/01/10 21:08:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_operator.h"
#include "catalog/pg_type.h"
+#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/params.h"
#include "optimizer/clauses.h"
#include "parser/parsetree.h"
#include "parser/parse_expr.h"
#include "parser/parse_oper.h"
+#include "utils/lsyscache.h"
#include "utils/syscache.h"
} finalize_primnode_results;
-static List *convert_sublink_opers(List *operlist, List *lefthand,
- List *targetlist, List **setParams);
+static List *convert_sublink_opers(List *lefthand, List *operOids,
+ List *targetlist, List **paramIds);
+static bool subplan_is_hashable(SubLink *slink, SubPlan *node);
static Node *replace_correlation_vars_mutator(Node *node, void *context);
static Node *process_sublinks_mutator(Node *node, void *context);
static bool finalize_primnode(Node *node, finalize_primnode_results *results);
node->rtable = subquery->rtable;
/*
- * Fill in other fields of the SubPlan node.
+ * Initialize other fields of the SubPlan node.
*/
node->subLinkType = slink->subLinkType;
node->useOr = slink->useOr;
- node->oper = NIL;
+ node->exprs = NIL;
+ node->paramIds = NIL;
+ node->useHashTable = false;
+ node->unknownEqFalse = false;
node->setParam = NIL;
node->parParam = NIL;
node->args = NIL;
TargetEntry *te = lfirst(plan->targetlist);
Param *prm;
+ Assert(!te->resdom->resjunk);
prm = generate_new_param(te->resdom->restype, te->resdom->restypmod);
node->setParam = lappendi(node->setParam, prm->paramid);
PlannerInitPlan = lappend(PlannerInitPlan, node);
}
else if (node->parParam == NIL && slink->subLinkType == MULTIEXPR_SUBLINK)
{
- List *oper;
-
- /* Convert the oper list, but don't put it into the SubPlan node */
- oper = convert_sublink_opers(slink->oper,
- lefthand,
- plan->targetlist,
- &node->setParam);
+ List *exprs;
+
+ /* Convert the lefthand exprs and oper OIDs into executable exprs */
+ exprs = convert_sublink_opers(lefthand,
+ slink->operOids,
+ plan->targetlist,
+ &node->paramIds);
+ node->setParam = nconc(node->setParam, listCopy(node->paramIds));
PlannerInitPlan = lappend(PlannerInitPlan, node);
- if (length(oper) > 1)
- result = (Node *) (node->useOr ? make_orclause(oper) :
- make_andclause(oper));
+ /*
+ * The executable expressions are returned to become part of the
+ * outer plan's expression tree; they are not kept in the initplan
+ * node.
+ */
+ if (length(exprs) > 1)
+ result = (Node *) (node->useOr ? make_orclause(exprs) :
+ make_andclause(exprs));
else
- result = (Node *) lfirst(oper);
+ result = (Node *) lfirst(exprs);
}
else
{
* We can't convert subplans of ALL_SUBLINK or ANY_SUBLINK types
* to initPlans, even when they are uncorrelated or undirect
* correlated, because we need to scan the output of the subplan
- * for each outer tuple. However, we have the option to tack a
- * MATERIAL node onto the top of an uncorrelated/undirect
- * correlated subplan, which lets us do the work of evaluating the
- * subplan only once. We do this if the subplan's top plan node
- * is anything more complicated than a plain sequential scan, and
- * we do it even for seqscan if the qual appears selective enough
- * to eliminate many tuples.
+ * for each outer tuple. But if it's an IN (= ANY) test, we might
+ * be able to use a hashtable to avoid comparing all the tuples.
+ */
+ if (subplan_is_hashable(slink, node))
+ node->useHashTable = true;
+ /*
+ * Otherwise, we have the option to tack a MATERIAL node onto the top
+ * of the subplan, to reduce the cost of reading it repeatedly. This
+ * is pointless for a direct-correlated subplan, since we'd have to
+ * recompute its results each time anyway. For uncorrelated/undirect
+ * correlated subplans, we add MATERIAL if the subplan's top plan node
+ * is anything more complicated than a plain sequential scan, and we
+ * do it even for seqscan if the qual appears selective enough to
+ * eliminate many tuples.
*
* XXX It's pretty ugly to be inserting a MATERIAL node at this
* point. Since subquery_planner has already run SS_finalize_plan
* the MATERIAL node. Possibly this could be fixed by postponing
* SS_finalize_plan processing until setrefs.c is run.
*/
- if (node->parParam == NIL)
+ else if (node->parParam == NIL)
{
bool use_material;
}
}
- /* Convert the SubLink's oper list into executable form */
- node->oper = convert_sublink_opers(slink->oper,
- lefthand,
- plan->targetlist,
- NULL);
+ /* Convert the lefthand exprs and oper OIDs into executable exprs */
+ node->exprs = convert_sublink_opers(lefthand,
+ slink->operOids,
+ plan->targetlist,
+ &node->paramIds);
/*
* Make node->args from parParam.
}
/*
- * convert_sublink_opers: convert a SubLink's oper list from the
- * parser/rewriter format into the executor's format.
+ * convert_sublink_opers: given a lefthand-expressions list and a list of
+ * operator OIDs, build a list of actually executable expressions. The
+ * righthand sides of the expressions are Params representing the results
+ * of the sub-select.
*
- * The oper list is initially a list of OpExpr nodes with NIL args. We
- * convert it to a list of actually executable expressions, in which the
- * specified operators are applied to corresponding elements of the
- * lefthand list and Params representing the results of the subplan.
- *
- * If setParams is not NULL, the paramids of the Params created are added
- * to the *setParams list.
+ * The paramids of the Params created are returned in the *paramIds list.
*/
static List *
-convert_sublink_opers(List *operlist, List *lefthand,
- List *targetlist, List **setParams)
+convert_sublink_opers(List *lefthand, List *operOids,
+ List *targetlist, List **paramIds)
{
- List *newoper = NIL;
- List *leftlist = lefthand;
+ List *result = NIL;
List *lst;
- foreach(lst, operlist)
+ *paramIds = NIL;
+
+ foreach(lst, operOids)
{
- OpExpr *oper = (OpExpr *) lfirst(lst);
- Node *leftop = lfirst(leftlist);
+ Oid opid = (Oid) lfirsti(lst);
+ Node *leftop = lfirst(lefthand);
TargetEntry *te = lfirst(targetlist);
Param *prm;
Operator tup;
Node *left,
*right;
+ Assert(!te->resdom->resjunk);
+
/* Make the Param node representing the subplan's result */
prm = generate_new_param(te->resdom->restype,
te->resdom->restypmod);
- /* Record its ID if needed */
- if (setParams)
- *setParams = lappendi(*setParams, prm->paramid);
+ /* Record its ID */
+ *paramIds = lappendi(*paramIds, prm->paramid);
- /* Look up the operator to check its declared input types */
- Assert(IsA(oper, OpExpr));
+ /* Look up the operator to get its declared input types */
tup = SearchSysCache(OPEROID,
- ObjectIdGetDatum(oper->opno),
+ ObjectIdGetDatum(opid),
0, 0, 0);
if (!HeapTupleIsValid(tup))
- elog(ERROR, "cache lookup failed for operator %u", oper->opno);
+ elog(ERROR, "cache lookup failed for operator %u", opid);
opform = (Form_pg_operator) GETSTRUCT(tup);
/*
*/
left = make_operand(leftop, exprType(leftop), opform->oprleft);
right = make_operand((Node *) prm, prm->paramtype, opform->oprright);
- newoper = lappend(newoper,
- make_opclause(oper->opno,
- oper->opresulttype,
- oper->opretset,
- (Expr *) left,
- (Expr *) right));
+ result = lappend(result,
+ make_opclause(opid,
+ opform->oprresult,
+ false, /* set-result not allowed */
+ (Expr *) left,
+ (Expr *) right));
ReleaseSysCache(tup);
- leftlist = lnext(leftlist);
+ lefthand = lnext(lefthand);
targetlist = lnext(targetlist);
}
- return newoper;
+ return result;
+}
+
+/*
+ * subplan_is_hashable: decide whether we can implement a subplan by hashing
+ *
+ * Caution: the SubPlan node is not completely filled in yet. We can rely
+ * on its plan and parParam fields, however.
+ */
+static bool
+subplan_is_hashable(SubLink *slink, SubPlan *node)
+{
+ double subquery_size;
+ List *opids;
+
+ /*
+ * The sublink type must be "= ANY" --- that is, an IN operator.
+ * (We require the operator name to be unqualified, which may be
+ * overly paranoid, or may not be.) XXX since we also check that the
+ * operators are hashable, the test on operator name may be redundant?
+ */
+ if (slink->subLinkType != ANY_SUBLINK)
+ return false;
+ if (length(slink->operName) != 1 ||
+ strcmp(strVal(lfirst(slink->operName)), "=") != 0)
+ return false;
+ /*
+ * The subplan must not have any direct correlation vars --- else we'd
+ * have to recompute its output each time, so that the hashtable wouldn't
+ * gain anything.
+ */
+ if (node->parParam != NIL)
+ return false;
+ /*
+ * The estimated size of the subquery result must fit in SortMem.
+ * (XXX what about hashtable overhead?)
+ */
+ subquery_size = node->plan->plan_rows *
+ (MAXALIGN(node->plan->plan_width) + MAXALIGN(sizeof(HeapTupleData)));
+ if (subquery_size > SortMem * 1024L)
+ return false;
+ /*
+ * The combining operators must be hashable and strict. (Without
+ * strictness, behavior in the presence of nulls is too unpredictable.
+ * We actually must assume even more than plain strictness, see
+ * nodeSubplan.c for details.)
+ */
+ foreach(opids, slink->operOids)
+ {
+ Oid opid = (Oid) lfirsti(opids);
+ HeapTuple tup;
+ Form_pg_operator optup;
+
+ tup = SearchSysCache(OPEROID,
+ ObjectIdGetDatum(opid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tup))
+ elog(ERROR, "cache lookup failed for operator %u", opid);
+ optup = (Form_pg_operator) GETSTRUCT(tup);
+ if (!optup->oprcanhash || !func_strict(optup->oprcode))
+ {
+ ReleaseSysCache(tup);
+ return false;
+ }
+ ReleaseSysCache(tup);
+ }
+ return true;
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.120 2002/12/15 16:17:50 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.121 2003/01/10 21:08:13 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
* mistakenly think that something like "WHERE random() < 0.5" can be treated
* as a constant qualification.
*
- * XXX we do not examine sublinks/subplans to see if they contain uses of
+ * XXX we do not examine sub-selects to see if they contain uses of
* mutable functions. It's not real clear if that is correct or not...
*/
bool
return true;
/* else fall through to check args */
}
+ if (IsA(node, SubLink))
+ {
+ SubLink *sublink = (SubLink *) node;
+ List *opid;
+
+ foreach(opid, sublink->operOids)
+ {
+ if (op_volatile((Oid) lfirsti(opid)) != PROVOLATILE_IMMUTABLE)
+ return true;
+ }
+ /* else fall through to check args */
+ }
return expression_tree_walker(node, contain_mutable_functions_walker,
context);
}
* volatile function) is found. This test prevents invalid conversions
* of volatile expressions into indexscan quals.
*
- * XXX we do not examine sublinks/subplans to see if they contain uses of
+ * XXX we do not examine sub-selects to see if they contain uses of
* volatile functions. It's not real clear if that is correct or not...
*/
bool
return true;
/* else fall through to check args */
}
+ if (IsA(node, SubLink))
+ {
+ SubLink *sublink = (SubLink *) node;
+ List *opid;
+
+ foreach(opid, sublink->operOids)
+ {
+ if (op_volatile((Oid) lfirsti(opid)) == PROVOLATILE_VOLATILE)
+ return true;
+ }
+ /* else fall through to check args */
+ }
return expression_tree_walker(node, contain_volatile_functions_walker,
context);
}
* Returns true if any nonstrict construct is found --- ie, anything that
* could produce non-NULL output with a NULL input.
*
- * XXX we do not examine sublinks/subplans to see if they contain uses of
+ * XXX we do not examine sub-selects to see if they contain uses of
* nonstrict functions. It's not real clear if that is correct or not...
* for the current usage it does not matter, since inline_function()
* rejects cases with sublinks.
return true;
if (IsA(node, BooleanTest))
return true;
+ if (IsA(node, SubLink))
+ {
+ SubLink *sublink = (SubLink *) node;
+ List *opid;
+
+ foreach(opid, sublink->operOids)
+ {
+ if (!op_strict((Oid) lfirsti(opid)))
+ return true;
+ }
+ /* else fall through to check args */
+ }
return expression_tree_walker(node, contain_nonstrict_functions_walker,
context);
}
* walker on all the expression subtrees of the given Query node.
*
* expression_tree_walker will handle SubPlan nodes by recursing normally
- * into the "oper" and "args" lists (which are expressions belonging to the
- * outer plan). It will not touch the completed subplan, however. Since
+ * into the "exprs" and "args" lists (which are expressions belonging to
+ * the outer plan). It will not touch the completed subplan, however. Since
* there is no link to the original Query, it is not possible to recurse into
* subselects of an already-planned expression tree. This is OK for current
* uses, but may need to be revisited in future.
{
SubLink *sublink = (SubLink *) node;
- /*
- * We only recurse into the lefthand list (the incomplete
- * OpExpr nodes in the oper list are deemed uninteresting,
- * perhaps even confusing).
- */
if (expression_tree_walker((Node *) sublink->lefthand,
walker, context))
return true;
{
SubPlan *subplan = (SubPlan *) node;
- /* recurse into the oper list, but not into the Plan */
- if (expression_tree_walker((Node *) subplan->oper,
+ /* recurse into the exprs list, but not into the Plan */
+ if (expression_tree_walker((Node *) subplan->exprs,
walker, context))
return true;
/* also examine args list */
* and qualifier clauses during the planning stage.
*
* expression_tree_mutator will handle a SubPlan node by recursing into
- * the "oper" and "args" lists (which belong to the outer plan), but it
+ * the "exprs" and "args" lists (which belong to the outer plan), but it
* will simply copy the link to the inner plan, since that's typically what
* expression tree mutators want. A mutator that wants to modify the subplan
* can force appropriate behavior by recognizing SubPlan expression nodes
case T_SubLink:
{
/*
- * We transform the lefthand side, but not the oper list nor
- * the subquery.
+ * We transform the lefthand side, but not the subquery.
*/
SubLink *sublink = (SubLink *) node;
SubLink *newnode;
SubPlan *newnode;
FLATCOPY(newnode, subplan, SubPlan);
+ /* transform exprs list */
+ MUTATE(newnode->exprs, subplan->exprs, List *);
/* transform args list (params to be passed to subplan) */
MUTATE(newnode->args, subplan->args, List *);
- /* transform oper list as well */
- MUTATE(newnode->oper, subplan->oper, List *);
/* but not the sub-Plan itself, which is referenced as-is */
return (Node *) newnode;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.42 2002/12/14 00:17:59 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.43 2003/01/10 21:08:13 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
/*
* Already-planned subquery. Examine the args list (parameters to
- * be passed to subquery), as well as the "oper" list which is
+ * be passed to subquery), as well as the exprs list which is
* executed by the outer query. But short-circuit recursion into
* the subquery itself, which would be a waste of effort.
*/
SubPlan *subplan = (SubPlan *) node;
- if (pull_varnos_walker((Node *) subplan->oper,
+ if (pull_varnos_walker((Node *) subplan->exprs,
context))
return true;
if (pull_varnos_walker((Node *) subplan->args,
{
/*
* Already-planned subquery. Examine the args list (parameters to
- * be passed to subquery), as well as the "oper" list which is
+ * be passed to subquery), as well as the exprs list which is
* executed by the outer query. But short-circuit recursion into
* the subquery itself, which would be a waste of effort.
*/
SubPlan *subplan = (SubPlan *) node;
- if (contain_var_reference_walker((Node *) subplan->oper,
+ if (contain_var_reference_walker((Node *) subplan->exprs,
context))
return true;
if (contain_var_reference_walker((Node *) subplan->args,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.393 2003/01/10 11:02:51 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.394 2003/01/10 21:08:13 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
r_expr: row IN_P select_with_parens
{
SubLink *n = makeNode(SubLink);
- n->lefthand = $1;
- n->oper = (List *) makeSimpleA_Expr(OP, "=", NULL, NULL);
n->subLinkType = ANY_SUBLINK;
- /* operIsEquals and useOr will be set later */
+ n->lefthand = $1;
+ n->operName = makeList1(makeString("="));
n->subselect = $3;
$$ = (Node *)n;
}
{
/* Make an IN node */
SubLink *n = makeNode(SubLink);
- n->lefthand = $1;
- n->oper = (List *) makeSimpleA_Expr(OP, "=", NULL, NULL);
n->subLinkType = ANY_SUBLINK;
- /* operIsEquals and useOr will be set later */
+ n->lefthand = $1;
+ n->operName = makeList1(makeString("="));
n->subselect = $4;
/* Stick a NOT on top */
$$ = (Node *) makeA_Expr(NOT, NIL, NULL, (Node *) n);
%prec Op
{
SubLink *n = makeNode(SubLink);
- n->lefthand = $1;
- n->oper = (List *) makeA_Expr(OP, $2, NULL, NULL);
n->subLinkType = $3;
- /* operIsEquals and useOr will be set later */
+ n->lefthand = $1;
+ n->operName = $2;
n->subselect = $4;
$$ = (Node *)n;
}
%prec Op
{
SubLink *n = makeNode(SubLink);
- n->lefthand = $1;
- n->oper = (List *) makeA_Expr(OP, $2, NULL, NULL);
n->subLinkType = MULTIEXPR_SUBLINK;
- /* operIsEquals and useOr will be set later */
+ n->lefthand = $1;
+ n->operName = $2;
n->subselect = $3;
$$ = (Node *)n;
}
if (IsA($3, SubLink))
{
SubLink *n = (SubLink *)$3;
- n->lefthand = makeList1($1);
- n->oper = (List *) makeSimpleA_Expr(OP, "=", NULL, NULL);
n->subLinkType = ANY_SUBLINK;
- /* operIsEquals and useOr will be set later */
+ n->lefthand = makeList1($1);
+ n->operName = makeList1(makeString("="));
$$ = (Node *)n;
}
else
{
/* Make an IN node */
SubLink *n = (SubLink *)$4;
- n->lefthand = makeList1($1);
- n->oper = (List *) makeSimpleA_Expr(OP, "=", NULL, NULL);
n->subLinkType = ANY_SUBLINK;
- /* operIsEquals and useOr will be set later */
+ n->lefthand = makeList1($1);
+ n->operName = makeList1(makeString("="));
/* Stick a NOT on top */
$$ = (Node *) makeA_Expr(NOT, NIL, NULL, (Node *) n);
}
| a_expr qual_all_Op sub_type select_with_parens %prec Op
{
SubLink *n = makeNode(SubLink);
- n->lefthand = makeList1($1);
- n->oper = (List *) makeA_Expr(OP, $2, NULL, NULL);
n->subLinkType = $3;
- /* operIsEquals and useOr will be set later */
+ n->lefthand = makeList1($1);
+ n->operName = $2;
n->subselect = $4;
$$ = (Node *)n;
}
| select_with_parens %prec UMINUS
{
SubLink *n = makeNode(SubLink);
- n->lefthand = NIL;
- n->oper = NIL;
n->subLinkType = EXPR_SUBLINK;
+ n->lefthand = NIL;
+ n->operName = NIL;
n->subselect = $1;
$$ = (Node *)n;
}
| EXISTS select_with_parens
{
SubLink *n = makeNode(SubLink);
- n->lefthand = NIL;
- n->oper = NIL;
n->subLinkType = EXISTS_SUBLINK;
+ n->lefthand = NIL;
+ n->operName = NIL;
n->subselect = $2;
$$ = (Node *)n;
}
{
SubLink *n = makeNode(SubLink);
n->subselect = $1;
+ /* other fields will be filled later */
$$ = (Node *)n;
}
| '(' expr_list ')' { $$ = (Node *)$2; }
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.139 2003/01/09 20:50:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.140 2003/01/10 21:08:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* These fields should be NIL already, but make sure.
*/
sublink->lefthand = NIL;
- sublink->oper = NIL;
- sublink->operIsEquals = FALSE;
+ sublink->operName = NIL;
+ sublink->operOids = NIL;
sublink->useOr = FALSE;
}
else if (sublink->subLinkType == EXPR_SUBLINK)
* fields should be NIL already, but make sure.
*/
sublink->lefthand = NIL;
- sublink->oper = NIL;
- sublink->operIsEquals = FALSE;
+ sublink->operName = NIL;
+ sublink->operOids = NIL;
sublink->useOr = FALSE;
}
else
List *right_list = qtree->targetList;
int row_length = length(left_list);
bool needNot = false;
- List *op;
- char *opname;
+ List *op = sublink->operName;
+ char *opname = strVal(llast(op));
List *elist;
/* transform lefthand expressions */
foreach(elist, left_list)
lfirst(elist) = transformExpr(pstate, lfirst(elist));
- /* get the combining-operator name */
- Assert(IsA(sublink->oper, A_Expr));
- op = ((A_Expr *) sublink->oper)->name;
- opname = strVal(llast(op));
- sublink->oper = NIL;
-
/*
* If the expression is "<> ALL" (with unqualified opname)
* then convert it to "NOT IN". This is a hack to improve
sublink->subLinkType = ANY_SUBLINK;
opname = pstrdup("=");
op = makeList1(makeString(opname));
+ sublink->operName = op;
needNot = true;
}
- /* Set operIsEquals if op is unqualified "=" */
- if (length(op) == 1 && strcmp(opname, "=") == 0)
- sublink->operIsEquals = TRUE;
- else
- sublink->operIsEquals = FALSE;
-
/* Set useOr if op is "<>" (possibly qualified) */
if (strcmp(opname, "<>") == 0)
sublink->useOr = TRUE;
opname);
/*
- * Scan subquery's targetlist to find values that will
+ * To build the list of combining operator OIDs, we must
+ * scan subquery's targetlist to find values that will
* be matched against lefthand values. We need to
* ignore resjunk targets, so doing the outer
* iteration over right_list is easier than doing it
* over left_list.
*/
+ sublink->operOids = NIL;
+
while (right_list != NIL)
{
TargetEntry *tent = (TargetEntry *) lfirst(right_list);
Node *lexpr;
Operator optup;
Form_pg_operator opform;
- OpExpr *newop;
right_list = lnext(right_list);
if (tent->resdom->resjunk)
" to be used with quantified predicate subquery",
opname);
- newop = makeNode(OpExpr);
- newop->opno = oprid(optup);
- newop->opfuncid = InvalidOid;
- newop->opresulttype = opform->oprresult;
- newop->opretset = false;
- newop->args = NIL; /* for now */
-
- sublink->oper = lappend(sublink->oper, newop);
+ sublink->operOids = lappendi(sublink->operOids,
+ oprid(optup));
ReleaseSysCache(optup);
}
* back to source text
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.131 2003/01/09 20:50:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.132 2003/01/10 21:08:15 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
static char *generate_relation_name(Oid relid);
static char *generate_function_name(Oid funcid, int nargs, Oid *argtypes);
static char *generate_operator_name(Oid operid, Oid arg1, Oid arg2);
+static void print_operator_name(StringInfo buf, List *opname);
static char *get_relid_attribute_name(Oid relid, AttrNumber attnum);
#define only_marker(rte) ((rte)->inh ? "" : "ONLY ")
* rule deparsing, only while EXPLAINing a query
* plan. For now, just punt.
*/
- appendStringInfo(buf, "(subplan)");
+ if (((SubPlan *) node)->useHashTable)
+ appendStringInfo(buf, "(hashed subplan)");
+ else
+ appendStringInfo(buf, "(subplan)");
}
break;
Query *query = (Query *) (sublink->subselect);
List *l;
char *sep;
- OpExpr *oper;
bool need_paren;
appendStringInfoChar(buf, '(');
need_paren = true;
/*
- * XXX we assume here that we can get away without qualifying the
- * operator name. Since the name may imply multiple physical
- * operators it's rather difficult to do otherwise --- in fact, if the
- * operators are in different namespaces any attempt to qualify would
- * surely fail.
+ * XXX we regurgitate the originally given operator name, with or without
+ * schema qualification. This is not necessarily 100% right but it's
+ * the best we can do, since the operators actually used might not all
+ * be in the same schema.
*/
switch (sublink->subLinkType)
{
break;
case ANY_SUBLINK:
- if (sublink->operIsEquals)
+ if (length(sublink->operName) == 1 &&
+ strcmp(strVal(lfirst(sublink->operName)), "=") == 0)
{
- /* Represent it as IN */
+ /* Represent = ANY as IN */
appendStringInfo(buf, "IN ");
}
else
{
- oper = (OpExpr *) lfirst(sublink->oper);
- appendStringInfo(buf, "%s ANY ", get_opname(oper->opno));
+ print_operator_name(buf, sublink->operName);
+ appendStringInfo(buf, " ANY ");
}
break;
case ALL_SUBLINK:
- oper = (OpExpr *) lfirst(sublink->oper);
- appendStringInfo(buf, "%s ALL ", get_opname(oper->opno));
+ print_operator_name(buf, sublink->operName);
+ appendStringInfo(buf, " ALL ");
break;
case MULTIEXPR_SUBLINK:
- oper = (OpExpr *) lfirst(sublink->oper);
- appendStringInfo(buf, "%s ", get_opname(oper->opno));
+ print_operator_name(buf, sublink->operName);
+ appendStringInfoChar(buf, ' ');
break;
case EXPR_SUBLINK:
return buf.data;
}
+/*
+ * Print out a possibly-qualified operator name
+ */
+static void
+print_operator_name(StringInfo buf, List *opname)
+{
+ int nnames = length(opname);
+
+ if (nnames == 1)
+ appendStringInfo(buf, "%s", strVal(lfirst(opname)));
+ else
+ {
+ appendStringInfo(buf, "OPERATOR(");
+ while (nnames-- > 1)
+ {
+ appendStringInfo(buf, "%s.",
+ quote_identifier(strVal(lfirst(opname))));
+ opname = lnext(opname);
+ }
+ appendStringInfo(buf, "%s)", strVal(lfirst(opname)));
+ }
+}
+
/*
* get_relid_attribute_name
* Get an attribute name by its relations Oid and its attnum
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: catversion.h,v 1.171 2003/01/09 20:50:53 tgl Exp $
+ * $Id: catversion.h,v 1.172 2003/01/10 21:08:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 200301091
+#define CATALOG_VERSION_NO 200301101
#endif
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: execnodes.h,v 1.88 2002/12/18 00:14:47 tgl Exp $
+ * $Id: execnodes.h,v 1.89 2003/01/10 21:08:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* SubPlanState node
* ----------------
*/
+/* this struct is private in nodeSubplan.c: */
+typedef struct SubPlanHashTableData *SubPlanHashTable;
+
typedef struct SubPlanState
{
ExprState xprstate;
EState *sub_estate; /* subselect plan has its own EState */
struct PlanState *planstate; /* subselect plan's state tree */
+ List *exprs; /* states of combining expression(s) */
+ List *args; /* states of argument expression(s) */
bool needShutdown; /* TRUE = need to shutdown subplan */
HeapTuple curTuple; /* copy of most recent tuple from subplan */
- List *oper; /* states for executable combining exprs */
- List *args; /* states of argument expression(s) */
+ /* these are used when hashing the subselect's output: */
+ SubPlanHashTable hashtable; /* hash table for no-nulls subselect rows */
+ SubPlanHashTable hashnulls; /* hash table for rows with null(s) */
} SubPlanState;
/* ----------------
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.76 2003/01/09 20:50:53 tgl Exp $
+ * $Id: primnodes.h,v 1.77 2003/01/10 21:08:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* it must be replaced in the expression tree by a SubPlan node during
* planning.
*
- * NOTE: in the raw output of gram.y, lefthand contains a list of (raw)
- * expressions, and oper contains a single A_Expr (not a list!) containing
- * the string name of the operator, but no arguments. Also, subselect is
- * a raw parsetree. During parse analysis, the parser transforms the
+ * NOTE: in the raw output of gram.y, lefthand contains a list of raw
+ * expressions; useOr and operOids are not filled in yet. Also, subselect
+ * is a raw parsetree. During parse analysis, the parser transforms the
* lefthand expression list using normal expression transformation rules.
- * It replaces oper with a list of OpExpr nodes, one per lefthand expression.
- * These nodes represent the parser's resolution of exactly which operator
- * to apply to each pair of lefthand and targetlist expressions. However,
- * we have not constructed complete Expr trees for these operations yet:
- * the args fields of the OpExpr nodes are NIL. And subselect is transformed
- * to a Query. This is the representation seen in saved rules and in the
- * rewriter.
- *
- * In EXISTS and EXPR SubLinks, both lefthand and oper are unused and are
- * always NIL. useOr is not significant either for these sublink types.
- *
- * The operIsEquals field is TRUE when the combining operator was written as
- * "=" --- if the subLinkType is ANY_SUBLINK, this means the operation is
- * equivalent to "IN". This case allows special optimizations to be used.
+ * It fills operOids with the OIDs representing the specific operator(s)
+ * to apply to each pair of lefthand and targetlist expressions.
+ * And subselect is transformed to a Query. This is the representation
+ * seen in saved rules and in the rewriter.
+ *
+ * In EXISTS and EXPR SubLinks, lefthand, operName, and operOids are unused
+ * and are always NIL. useOr is not significant either for these sublink
+ * types.
* ----------------
*/
typedef enum SubLinkType
{
Expr xpr;
SubLinkType subLinkType; /* EXISTS, ALL, ANY, MULTIEXPR, EXPR */
- bool operIsEquals; /* TRUE if combining operator is "=" */
bool useOr; /* TRUE to combine column results with
* "OR" not "AND" */
List *lefthand; /* list of outer-query expressions on the
* left */
- List *oper; /* list of arg-less OpExpr nodes for
- * combining operators */
+ List *operName; /* originally specified operator name */
+ List *operOids; /* OIDs of actual combining operators */
Node *subselect; /* subselect as Query* or parsetree */
} SubLink;
*
* The planner replaces SubLink nodes in expression trees with SubPlan
* nodes after it has finished planning the subquery. SubPlan contains
- * a sub-plantree and rtable instead of a sub-Query. Its "oper" field
- * corresponds to the original SubLink's oper list, but has been expanded
- * into valid executable expressions representing the application of the
- * combining operator(s) to the lefthand expressions and values from the
- * inner targetlist. The original lefthand expressions now appear as
- * left-hand arguments of the OpExpr nodes, while the inner targetlist items
- * are represented by PARAM_EXEC Param nodes. (Note: if the sub-select
- * becomes an InitPlan rather than a SubPlan, the rebuilt oper list is
- * part of the outer plan tree and so is not stored in the oper field.)
+ * a sub-plantree and rtable instead of a sub-Query.
+ *
+ * In an ordinary subplan, "exprs" points to a list of executable expressions
+ * (OpExpr trees) for the combining operators; their left-hand arguments are
+ * the original lefthand expressions, and their right-hand arguments are
+ * PARAM_EXEC Param nodes representing the outputs of the sub-select.
+ * (NOTE: runtime coercion functions may be inserted as well.) But if the
+ * sub-select becomes an initplan rather than a subplan, these executable
+ * expressions are part of the outer plan's expression tree (and the SubPlan
+ * node itself is not). In this case "exprs" is NIL to avoid duplication.
*
* The planner also derives lists of the values that need to be passed into
* and out of the subplan. Input values are represented as a list "args" of
* The values are assigned to the global PARAM_EXEC params indexed by parParam
* (the parParam and args lists must have the same length). setParam is a
* list of the PARAM_EXEC params that are computed by the sub-select, if it
- * is an initPlan.
+ * is an initplan.
*/
typedef struct SubPlan
{
SubLinkType subLinkType; /* EXISTS, ALL, ANY, MULTIEXPR, EXPR */
bool useOr; /* TRUE to combine column results with
* "OR" not "AND" */
- List *oper; /* list of executable expressions for
- * combining operators (with arguments) */
+ /* The combining operators, transformed to executable expressions: */
+ List *exprs; /* list of OpExpr expression trees */
+ List *paramIds; /* IDs of Params embedded in the above */
/* The subselect, transformed to a Plan: */
struct Plan *plan; /* subselect plan itself */
int plan_id; /* dummy thing because of we haven't equal
* could put *plan itself somewhere else
* (TopPlan node ?)... */
List *rtable; /* range table for subselect */
+ /* Information about execution strategy: */
+ bool useHashTable; /* TRUE to store subselect output in a hash
+ * table (implies we are doing "IN") */
+ bool unknownEqFalse; /* TRUE if it's okay to return FALSE when
+ * the spec result is UNKNOWN; this allows
+ * much simpler handling of null values */
/* Information for passing params into and out of the subselect: */
/* setParam and parParam are lists of integers (param IDs) */
- List *setParam; /* non-correlated EXPR & EXISTS subqueries
- * have to set some Params for paren Plan */
+ List *setParam; /* initplan subqueries have to set these
+ * Params for parent plan */
List *parParam; /* indices of input Params from parent plan */
List *args; /* exprs to pass as parParam values */
} SubPlan;
projects / postgresql.git / commitdiff