1998-02-13 04:37:04 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* subselect.c
|
1999-06-21 03:20:57 +02:00
|
|
|
* Planning routines for subselects and parameters.
|
|
|
|
*
|
2002-06-20 22:29:54 +02:00
|
|
|
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1999-06-21 03:20:57 +02:00
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2003-02-09 07:56:28 +01:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.72 2003/02/09 06:56:27 tgl Exp $
|
1998-02-13 04:37:04 +01:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
#include "catalog/pg_operator.h"
|
1998-02-13 04:37:04 +01:00
|
|
|
#include "catalog/pg_type.h"
|
2003-01-10 22:08:15 +01:00
|
|
|
#include "miscadmin.h"
|
1998-02-13 04:37:04 +01:00
|
|
|
#include "nodes/makefuncs.h"
|
2002-12-05 16:50:39 +01:00
|
|
|
#include "nodes/params.h"
|
1998-02-13 04:37:04 +01:00
|
|
|
#include "optimizer/clauses.h"
|
2000-03-02 05:08:16 +01:00
|
|
|
#include "optimizer/cost.h"
|
|
|
|
#include "optimizer/planmain.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "optimizer/planner.h"
|
|
|
|
#include "optimizer/subselect.h"
|
2003-01-20 19:55:07 +01:00
|
|
|
#include "optimizer/var.h"
|
2002-05-18 20:49:41 +02:00
|
|
|
#include "parser/parsetree.h"
|
1999-08-26 01:21:43 +02:00
|
|
|
#include "parser/parse_expr.h"
|
|
|
|
#include "parser/parse_oper.h"
|
2003-01-20 19:55:07 +01:00
|
|
|
#include "parser/parse_relation.h"
|
2003-01-10 22:08:15 +01:00
|
|
|
#include "utils/lsyscache.h"
|
2000-11-16 23:30:52 +01:00
|
|
|
#include "utils/syscache.h"
|
1999-08-26 01:21:43 +02:00
|
|
|
|
1998-02-13 04:37:04 +01:00
|
|
|
|
2000-03-17 03:36:41 +01:00
|
|
|
Index PlannerQueryLevel; /* level of current query */
|
1998-02-26 05:46:47 +01:00
|
|
|
List *PlannerInitPlan; /* init subplans for current query */
|
1999-06-21 03:20:57 +02:00
|
|
|
List *PlannerParamVar; /* to get Var from Param->paramid */
|
2000-10-05 21:11:39 +02:00
|
|
|
|
|
|
|
int PlannerPlanId = 0; /* to assign unique ID to subquery plans */
|
1999-06-21 03:20:57 +02:00
|
|
|
|
|
|
|
/*--------------------
|
|
|
|
* PlannerParamVar is a list of Var nodes, wherein the n'th entry
|
|
|
|
* (n counts from 0) corresponds to Param->paramid = n. The Var nodes
|
|
|
|
* are ordinary except for one thing: their varlevelsup field does NOT
|
|
|
|
* have the usual interpretation of "subplan levels out from current".
|
|
|
|
* Instead, it contains the absolute plan level, with the outermost
|
|
|
|
* plan being level 1 and nested plans having higher level numbers.
|
|
|
|
* This nonstandardness is useful because we don't have to run around
|
|
|
|
* and update the list elements when we enter or exit a subplan
|
|
|
|
* recursion level. But we must pay attention not to confuse this
|
|
|
|
* meaning with the normal meaning of varlevelsup.
|
2002-11-26 04:01:59 +01:00
|
|
|
*
|
|
|
|
* We also need to create Param slots that don't correspond to any outer Var.
|
|
|
|
* For these, we set varno = 0 and varlevelsup = 0, so that they can't
|
|
|
|
* accidentally match an outer Var.
|
1999-06-21 03:20:57 +02:00
|
|
|
*--------------------
|
|
|
|
*/
|
1998-02-13 04:37:04 +01:00
|
|
|
|
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
typedef struct finalize_primnode_context
|
2002-12-14 01:17:59 +01:00
|
|
|
{
|
2003-02-09 01:30:41 +01:00
|
|
|
Bitmapset *paramids; /* Set of PARAM_EXEC paramids found */
|
|
|
|
Bitmapset *outer_params; /* Set of accessible outer paramids */
|
|
|
|
} finalize_primnode_context;
|
2002-12-14 01:17:59 +01:00
|
|
|
|
|
|
|
|
2003-01-10 22:08:15 +01:00
|
|
|
static List *convert_sublink_opers(List *lefthand, List *operOids,
|
2003-01-20 19:55:07 +01:00
|
|
|
List *targetlist, int rtindex,
|
|
|
|
List **righthandIds);
|
2003-01-10 22:08:15 +01:00
|
|
|
static bool subplan_is_hashable(SubLink *slink, SubPlan *node);
|
2002-12-14 01:17:59 +01:00
|
|
|
static Node *replace_correlation_vars_mutator(Node *node, void *context);
|
2003-01-13 19:10:53 +01:00
|
|
|
static Node *process_sublinks_mutator(Node *node, bool *isTopQual);
|
2003-02-09 01:30:41 +01:00
|
|
|
static Bitmapset *finalize_plan(Plan *plan, List *rtable,
|
|
|
|
Bitmapset *outer_params,
|
|
|
|
Bitmapset *valid_params);
|
|
|
|
static bool finalize_primnode(Node *node, finalize_primnode_context *context);
|
2002-11-26 04:01:59 +01:00
|
|
|
|
|
|
|
|
1999-06-21 03:20:57 +02:00
|
|
|
/*
|
|
|
|
* Create a new entry in the PlannerParamVar list, and return its index.
|
|
|
|
*
|
2002-11-26 04:01:59 +01:00
|
|
|
* var contains the data to use, except for varlevelsup which
|
|
|
|
* is set from the absolute level value given by varlevel. NOTE that
|
|
|
|
* the passed var is scribbled on and placed directly into the list!
|
|
|
|
* Generally, caller should have just created or copied it.
|
1999-06-21 03:20:57 +02:00
|
|
|
*/
|
1998-02-13 04:37:04 +01:00
|
|
|
static int
|
2000-03-17 03:36:41 +01:00
|
|
|
new_param(Var *var, Index varlevel)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2002-11-26 04:01:59 +01:00
|
|
|
var->varlevelsup = varlevel;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2002-11-26 04:01:59 +01:00
|
|
|
PlannerParamVar = lappend(PlannerParamVar, var);
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1999-08-22 22:15:04 +02:00
|
|
|
return length(PlannerParamVar) - 1;
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
|
|
|
|
1999-06-21 03:20:57 +02:00
|
|
|
/*
|
|
|
|
* Generate a Param node to replace the given Var,
|
|
|
|
* which is expected to have varlevelsup > 0 (ie, it is not local).
|
|
|
|
*/
|
1998-02-26 05:46:47 +01:00
|
|
|
static Param *
|
1999-08-26 01:21:43 +02:00
|
|
|
replace_var(Var *var)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
1999-06-21 03:20:57 +02:00
|
|
|
List *ppv;
|
1998-02-26 05:46:47 +01:00
|
|
|
Param *retval;
|
2000-03-17 03:36:41 +01:00
|
|
|
Index varlevel;
|
1998-02-26 05:46:47 +01:00
|
|
|
int i;
|
|
|
|
|
1999-06-21 03:20:57 +02:00
|
|
|
Assert(var->varlevelsup > 0 && var->varlevelsup < PlannerQueryLevel);
|
|
|
|
varlevel = PlannerQueryLevel - var->varlevelsup;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1999-06-21 03:20:57 +02:00
|
|
|
/*
|
2000-04-12 19:17:23 +02:00
|
|
|
* If there's already a PlannerParamVar entry for this same Var, just
|
2001-03-22 05:01:46 +01:00
|
|
|
* use it. NOTE: in sufficiently complex querytrees, it is possible
|
|
|
|
* for the same varno/varlevel to refer to different RTEs in different
|
|
|
|
* parts of the parsetree, so that different fields might end up
|
|
|
|
* sharing the same Param number. As long as we check the vartype as
|
|
|
|
* well, I believe that this sort of aliasing will cause no trouble.
|
|
|
|
* The correct field should get stored into the Param slot at
|
2000-04-12 19:17:23 +02:00
|
|
|
* execution in each part of the tree.
|
1999-06-21 03:20:57 +02:00
|
|
|
*/
|
|
|
|
i = 0;
|
|
|
|
foreach(ppv, PlannerParamVar)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
Var *pvar = lfirst(ppv);
|
1999-06-21 03:20:57 +02:00
|
|
|
|
|
|
|
if (pvar->varno == var->varno &&
|
|
|
|
pvar->varattno == var->varattno &&
|
|
|
|
pvar->varlevelsup == varlevel &&
|
|
|
|
pvar->vartype == var->vartype)
|
1998-02-13 04:37:04 +01:00
|
|
|
break;
|
1999-06-21 03:20:57 +02:00
|
|
|
i++;
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
if (!ppv)
|
1999-06-21 03:20:57 +02:00
|
|
|
{
|
|
|
|
/* Nope, so make a new one */
|
2002-11-26 04:01:59 +01:00
|
|
|
i = new_param((Var *) copyObject(var), varlevel);
|
1999-06-21 03:20:57 +02:00
|
|
|
}
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1998-02-13 04:37:04 +01:00
|
|
|
retval = makeNode(Param);
|
|
|
|
retval->paramkind = PARAM_EXEC;
|
|
|
|
retval->paramid = (AttrNumber) i;
|
|
|
|
retval->paramtype = var->vartype;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return retval;
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
|
|
|
|
2002-11-26 04:01:59 +01:00
|
|
|
/*
|
|
|
|
* Generate a new Param node that will not conflict with any other.
|
|
|
|
*/
|
|
|
|
static Param *
|
|
|
|
generate_new_param(Oid paramtype, int32 paramtypmod)
|
|
|
|
{
|
|
|
|
Var *var = makeVar(0, 0, paramtype, paramtypmod, 0);
|
|
|
|
Param *retval = makeNode(Param);
|
|
|
|
|
|
|
|
retval->paramkind = PARAM_EXEC;
|
|
|
|
retval->paramid = (AttrNumber) new_param(var, 0);
|
|
|
|
retval->paramtype = paramtype;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
/*
|
2002-12-14 01:17:59 +01:00
|
|
|
* Convert a bare SubLink (as created by the parser) into a SubPlan.
|
|
|
|
*
|
|
|
|
* We are given the raw SubLink and the already-processed lefthand argument
|
2003-01-13 19:10:53 +01:00
|
|
|
* list (use this instead of the SubLink's own field). We are also told if
|
|
|
|
* this expression appears at top level of a WHERE/HAVING qual.
|
2002-12-14 01:17:59 +01:00
|
|
|
*
|
|
|
|
* The result is whatever we need to substitute in place of the SubLink
|
|
|
|
* node in the executable expression. This will be either the SubPlan
|
|
|
|
* node (if we have to do the subplan as a subplan), or a Param node
|
|
|
|
* representing the result of an InitPlan, or possibly an AND or OR tree
|
|
|
|
* containing InitPlan Param nodes.
|
1999-08-26 01:21:43 +02:00
|
|
|
*/
|
1998-02-26 05:46:47 +01:00
|
|
|
static Node *
|
2003-01-13 19:10:53 +01:00
|
|
|
make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2002-12-14 01:17:59 +01:00
|
|
|
SubPlan *node = makeNode(SubPlan);
|
2000-03-02 05:08:16 +01:00
|
|
|
Query *subquery = (Query *) (slink->subselect);
|
2000-02-15 21:49:31 +01:00
|
|
|
double tuple_fraction;
|
1998-02-13 04:37:04 +01:00
|
|
|
Plan *plan;
|
2003-02-09 01:30:41 +01:00
|
|
|
Bitmapset *tmpset;
|
|
|
|
int paramid;
|
1998-02-13 04:37:04 +01:00
|
|
|
List *lst;
|
|
|
|
Node *result;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-08-06 06:13:22 +02:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* Copy the source Query node. This is a quick and dirty kluge to
|
|
|
|
* resolve the fact that the parser can generate trees with multiple
|
|
|
|
* links to the same sub-Query node, but the planner wants to scribble
|
|
|
|
* on the Query. Try to clean this up when we do querytree redesign...
|
2000-08-06 06:13:22 +02:00
|
|
|
*/
|
|
|
|
subquery = (Query *) copyObject(subquery);
|
|
|
|
|
2000-02-15 21:49:31 +01:00
|
|
|
/*
|
2000-04-12 19:17:23 +02:00
|
|
|
* For an EXISTS subplan, tell lower-level planner to expect that only
|
|
|
|
* the first tuple will be retrieved. For ALL and ANY subplans, we
|
|
|
|
* will be able to stop evaluating if the test condition fails, so
|
|
|
|
* very often not all the tuples will be retrieved; for lack of a
|
|
|
|
* better idea, specify 50% retrieval. For EXPR and MULTIEXPR
|
|
|
|
* subplans, use default behavior (we're only expecting one row out,
|
|
|
|
* anyway).
|
2000-02-15 21:49:31 +01:00
|
|
|
*
|
2000-03-14 03:23:15 +01:00
|
|
|
* NOTE: if you change these numbers, also change cost_qual_eval_walker()
|
|
|
|
* in path/costsize.c.
|
|
|
|
*
|
2003-01-12 05:03:34 +01:00
|
|
|
* XXX If an ALL/ANY subplan is uncorrelated, we may decide to hash or
|
|
|
|
* materialize its result below. In that case it would've been better to
|
|
|
|
* specify full retrieval. At present, however, we can only detect
|
2000-04-12 19:17:23 +02:00
|
|
|
* correlation or lack of it after we've made the subplan :-(. Perhaps
|
|
|
|
* detection of correlation should be done as a separate step.
|
|
|
|
* Meanwhile, we don't want to be too optimistic about the percentage
|
|
|
|
* of tuples retrieved, for fear of selecting a plan that's bad for
|
|
|
|
* the materialization case.
|
2000-02-15 21:49:31 +01:00
|
|
|
*/
|
|
|
|
if (slink->subLinkType == EXISTS_SUBLINK)
|
|
|
|
tuple_fraction = 1.0; /* just like a LIMIT 1 */
|
2000-03-14 03:23:15 +01:00
|
|
|
else if (slink->subLinkType == ALL_SUBLINK ||
|
|
|
|
slink->subLinkType == ANY_SUBLINK)
|
2000-02-15 21:49:31 +01:00
|
|
|
tuple_fraction = 0.5; /* 50% */
|
2000-03-14 03:23:15 +01:00
|
|
|
else
|
|
|
|
tuple_fraction = -1.0; /* default behavior */
|
2000-02-15 21:49:31 +01:00
|
|
|
|
1998-02-26 05:46:47 +01:00
|
|
|
/*
|
2000-10-05 21:11:39 +02:00
|
|
|
* Generate the plan for the subquery.
|
1998-02-13 04:37:04 +01:00
|
|
|
*/
|
2000-10-05 21:11:39 +02:00
|
|
|
node->plan = plan = subquery_planner(subquery, tuple_fraction);
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2001-03-22 05:01:46 +01:00
|
|
|
node->plan_id = PlannerPlanId++; /* Assign unique ID to this
|
2002-12-14 01:17:59 +01:00
|
|
|
* SubPlan */
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-03-02 05:08:16 +01:00
|
|
|
node->rtable = subquery->rtable;
|
2002-12-12 16:49:42 +01:00
|
|
|
|
2002-12-14 01:17:59 +01:00
|
|
|
/*
|
2003-01-10 22:08:15 +01:00
|
|
|
* Initialize other fields of the SubPlan node.
|
2002-12-14 01:17:59 +01:00
|
|
|
*/
|
|
|
|
node->subLinkType = slink->subLinkType;
|
2003-01-09 21:50:53 +01:00
|
|
|
node->useOr = slink->useOr;
|
2003-01-10 22:08:15 +01:00
|
|
|
node->exprs = NIL;
|
|
|
|
node->paramIds = NIL;
|
|
|
|
node->useHashTable = false;
|
2003-01-13 19:10:53 +01:00
|
|
|
/* At top level of a qual, can treat UNKNOWN the same as FALSE */
|
|
|
|
node->unknownEqFalse = isTopQual;
|
2002-12-14 01:17:59 +01:00
|
|
|
node->setParam = NIL;
|
|
|
|
node->parParam = NIL;
|
|
|
|
node->args = NIL;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-10-05 21:11:39 +02:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* Make parParam list of params that current query level will pass to
|
|
|
|
* this child plan.
|
2000-10-05 21:11:39 +02:00
|
|
|
*/
|
2003-02-09 01:30:41 +01:00
|
|
|
tmpset = bms_copy(plan->extParam);
|
|
|
|
while ((paramid = bms_first_member(tmpset)) >= 0)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2000-10-05 21:11:39 +02:00
|
|
|
Var *var = nth(paramid, PlannerParamVar);
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1999-06-21 03:20:57 +02:00
|
|
|
/* note varlevelsup is absolute level number */
|
1998-02-26 05:46:47 +01:00
|
|
|
if (var->varlevelsup == PlannerQueryLevel)
|
2000-10-05 21:11:39 +02:00
|
|
|
node->parParam = lappendi(node->parParam, paramid);
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
2003-02-09 01:30:41 +01:00
|
|
|
bms_free(tmpset);
|
1998-02-26 05:46:47 +01:00
|
|
|
|
|
|
|
/*
|
1999-11-15 03:00:15 +01:00
|
|
|
* Un-correlated or undirect correlated plans of EXISTS, EXPR, or
|
2000-04-12 19:17:23 +02:00
|
|
|
* MULTIEXPR types can be used as initPlans. For EXISTS or EXPR, we
|
|
|
|
* just produce a Param referring to the result of evaluating the
|
1999-11-15 03:00:15 +01:00
|
|
|
* initPlan. For MULTIEXPR, we must build an AND or OR-clause of the
|
|
|
|
* individual comparison operators, using the appropriate lefthand
|
|
|
|
* side expressions and Params for the initPlan's target items.
|
1998-02-13 04:37:04 +01:00
|
|
|
*/
|
1999-11-15 03:00:15 +01:00
|
|
|
if (node->parParam == NIL && slink->subLinkType == EXISTS_SUBLINK)
|
|
|
|
{
|
2002-11-26 04:01:59 +01:00
|
|
|
Param *prm;
|
1999-11-15 03:00:15 +01:00
|
|
|
|
2002-11-26 04:01:59 +01:00
|
|
|
prm = generate_new_param(BOOLOID, -1);
|
2003-02-09 01:30:41 +01:00
|
|
|
node->setParam = makeListi1(prm->paramid);
|
1999-11-15 03:00:15 +01:00
|
|
|
PlannerInitPlan = lappend(PlannerInitPlan, node);
|
|
|
|
result = (Node *) prm;
|
|
|
|
}
|
|
|
|
else if (node->parParam == NIL && slink->subLinkType == EXPR_SUBLINK)
|
|
|
|
{
|
|
|
|
TargetEntry *te = lfirst(plan->targetlist);
|
2002-11-26 04:01:59 +01:00
|
|
|
Param *prm;
|
2000-04-12 19:17:23 +02:00
|
|
|
|
2003-01-10 22:08:15 +01:00
|
|
|
Assert(!te->resdom->resjunk);
|
2002-11-26 04:01:59 +01:00
|
|
|
prm = generate_new_param(te->resdom->restype, te->resdom->restypmod);
|
2003-02-09 01:30:41 +01:00
|
|
|
node->setParam = makeListi1(prm->paramid);
|
1999-11-15 03:00:15 +01:00
|
|
|
PlannerInitPlan = lappend(PlannerInitPlan, node);
|
|
|
|
result = (Node *) prm;
|
|
|
|
}
|
|
|
|
else if (node->parParam == NIL && slink->subLinkType == MULTIEXPR_SUBLINK)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2003-01-10 22:08:15 +01:00
|
|
|
List *exprs;
|
|
|
|
|
|
|
|
/* Convert the lefthand exprs and oper OIDs into executable exprs */
|
|
|
|
exprs = convert_sublink_opers(lefthand,
|
|
|
|
slink->operOids,
|
|
|
|
plan->targetlist,
|
2003-01-20 19:55:07 +01:00
|
|
|
0,
|
2003-01-10 22:08:15 +01:00
|
|
|
&node->paramIds);
|
2003-02-09 01:30:41 +01:00
|
|
|
node->setParam = listCopy(node->paramIds);
|
1998-02-26 05:46:47 +01:00
|
|
|
PlannerInitPlan = lappend(PlannerInitPlan, node);
|
2003-01-10 22:08:15 +01:00
|
|
|
/*
|
|
|
|
* 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));
|
1998-02-13 04:37:04 +01:00
|
|
|
else
|
2003-01-10 22:08:15 +01:00
|
|
|
result = (Node *) lfirst(exprs);
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
1998-02-26 05:46:47 +01:00
|
|
|
else
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2002-12-14 01:17:59 +01:00
|
|
|
List *args;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-03-02 05:08:16 +01:00
|
|
|
/*
|
2000-04-12 19:17:23 +02:00
|
|
|
* 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
|
2003-01-10 22:08:15 +01:00
|
|
|
* 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.
|
2001-11-30 20:24:15 +01:00
|
|
|
*
|
|
|
|
* XXX It's pretty ugly to be inserting a MATERIAL node at this
|
|
|
|
* point. Since subquery_planner has already run SS_finalize_plan
|
|
|
|
* on the subplan tree, we have to kluge up parameter lists for
|
|
|
|
* the MATERIAL node. Possibly this could be fixed by postponing
|
|
|
|
* SS_finalize_plan processing until setrefs.c is run.
|
2000-03-02 05:08:16 +01:00
|
|
|
*/
|
2003-01-10 22:08:15 +01:00
|
|
|
else if (node->parParam == NIL)
|
2000-03-02 05:08:16 +01:00
|
|
|
{
|
|
|
|
bool use_material;
|
|
|
|
|
|
|
|
switch (nodeTag(plan))
|
|
|
|
{
|
|
|
|
case T_SeqScan:
|
2002-12-05 16:50:39 +01:00
|
|
|
if (plan->initPlan)
|
2000-03-12 00:53:41 +01:00
|
|
|
use_material = true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Selectivity qualsel;
|
|
|
|
|
|
|
|
qualsel = clauselist_selectivity(subquery,
|
|
|
|
plan->qual,
|
2003-01-28 23:13:41 +01:00
|
|
|
0, JOIN_INNER);
|
2000-03-12 00:53:41 +01:00
|
|
|
/* Is 10% selectivity a good threshold?? */
|
|
|
|
use_material = qualsel < 0.10;
|
|
|
|
}
|
2000-03-02 05:08:16 +01:00
|
|
|
break;
|
|
|
|
case T_Material:
|
2002-05-12 22:10:05 +02:00
|
|
|
case T_FunctionScan:
|
2000-03-02 05:08:16 +01:00
|
|
|
case T_Sort:
|
2000-04-12 19:17:23 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't add another Material node if there's one
|
2002-05-12 22:10:05 +02:00
|
|
|
* already, nor if the top node is any other type that
|
|
|
|
* materializes its output anyway.
|
2000-03-02 05:08:16 +01:00
|
|
|
*/
|
|
|
|
use_material = false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
use_material = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (use_material)
|
|
|
|
{
|
2002-09-04 22:31:48 +02:00
|
|
|
Plan *matplan;
|
2002-11-30 06:21:03 +01:00
|
|
|
Path matpath; /* dummy for result of cost_material */
|
2001-11-30 20:24:15 +01:00
|
|
|
|
|
|
|
matplan = (Plan *) make_material(plan->targetlist, plan);
|
2002-11-30 06:21:03 +01:00
|
|
|
/* need to calculate costs */
|
|
|
|
cost_material(&matpath,
|
|
|
|
plan->total_cost,
|
|
|
|
plan->plan_rows,
|
|
|
|
plan->plan_width);
|
|
|
|
matplan->startup_cost = matpath.startup_cost;
|
|
|
|
matplan->total_cost = matpath.total_cost;
|
2003-01-13 01:29:26 +01:00
|
|
|
matplan->plan_rows = plan->plan_rows;
|
|
|
|
matplan->plan_width = plan->plan_width;
|
2002-11-30 06:21:03 +01:00
|
|
|
/* parameter kluge --- see comments above */
|
2003-02-09 01:30:41 +01:00
|
|
|
matplan->extParam = bms_copy(plan->extParam);
|
|
|
|
matplan->allParam = bms_copy(plan->allParam);
|
2001-11-30 20:24:15 +01:00
|
|
|
node->plan = plan = matplan;
|
2000-03-02 05:08:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-01-10 22:08:15 +01:00
|
|
|
/* Convert the lefthand exprs and oper OIDs into executable exprs */
|
|
|
|
node->exprs = convert_sublink_opers(lefthand,
|
|
|
|
slink->operOids,
|
|
|
|
plan->targetlist,
|
2003-01-20 19:55:07 +01:00
|
|
|
0,
|
2003-01-10 22:08:15 +01:00
|
|
|
&node->paramIds);
|
2002-11-26 04:01:59 +01:00
|
|
|
|
2000-03-02 05:08:16 +01:00
|
|
|
/*
|
2002-12-12 16:49:42 +01:00
|
|
|
* Make node->args from parParam.
|
1998-02-13 04:37:04 +01:00
|
|
|
*/
|
2002-12-14 01:17:59 +01:00
|
|
|
args = NIL;
|
1998-02-26 05:46:47 +01:00
|
|
|
foreach(lst, node->parParam)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
1998-02-26 05:46:47 +01:00
|
|
|
Var *var = nth(lfirsti(lst), PlannerParamVar);
|
|
|
|
|
|
|
|
var = (Var *) copyObject(var);
|
2000-04-12 19:17:23 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Must fix absolute-level varlevelsup from the
|
|
|
|
* PlannerParamVar entry. But since var is at current subplan
|
|
|
|
* level, this is easy:
|
1999-06-21 03:20:57 +02:00
|
|
|
*/
|
1998-02-13 04:37:04 +01:00
|
|
|
var->varlevelsup = 0;
|
1998-02-26 05:46:47 +01:00
|
|
|
args = lappend(args, var);
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
2002-12-12 16:49:42 +01:00
|
|
|
node->args = args;
|
2000-04-12 19:17:23 +02:00
|
|
|
|
2002-12-12 16:49:42 +01:00
|
|
|
result = (Node *) node;
|
2002-11-26 04:01:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2003-01-10 22:08:15 +01:00
|
|
|
* convert_sublink_opers: given a lefthand-expressions list and a list of
|
|
|
|
* operator OIDs, build a list of actually executable expressions. The
|
2003-01-20 19:55:07 +01:00
|
|
|
* righthand sides of the expressions are Params or Vars representing the
|
|
|
|
* results of the sub-select.
|
2002-11-26 04:01:59 +01:00
|
|
|
*
|
2003-01-20 19:55:07 +01:00
|
|
|
* If rtindex is 0, we build Params to represent the sub-select outputs.
|
|
|
|
* The paramids of the Params created are returned in the *righthandIds list.
|
|
|
|
*
|
|
|
|
* If rtindex is not 0, we build Vars using that rtindex as varno. The
|
|
|
|
* Vars themselves are returned in *righthandIds (this is a bit of a type
|
|
|
|
* cheat, but we can get away with it).
|
2002-11-26 04:01:59 +01:00
|
|
|
*/
|
2002-12-14 01:17:59 +01:00
|
|
|
static List *
|
2003-01-10 22:08:15 +01:00
|
|
|
convert_sublink_opers(List *lefthand, List *operOids,
|
2003-01-20 19:55:07 +01:00
|
|
|
List *targetlist, int rtindex,
|
|
|
|
List **righthandIds)
|
2002-11-26 04:01:59 +01:00
|
|
|
{
|
2003-01-10 22:08:15 +01:00
|
|
|
List *result = NIL;
|
2002-11-26 04:01:59 +01:00
|
|
|
List *lst;
|
|
|
|
|
2003-01-20 19:55:07 +01:00
|
|
|
*righthandIds = NIL;
|
2003-01-10 22:08:15 +01:00
|
|
|
|
|
|
|
foreach(lst, operOids)
|
2002-11-26 04:01:59 +01:00
|
|
|
{
|
2003-02-09 07:56:28 +01:00
|
|
|
Oid opid = lfirsto(lst);
|
2003-01-10 22:08:15 +01:00
|
|
|
Node *leftop = lfirst(lefthand);
|
2002-11-26 04:01:59 +01:00
|
|
|
TargetEntry *te = lfirst(targetlist);
|
2003-01-20 19:55:07 +01:00
|
|
|
Node *rightop;
|
2002-11-26 04:01:59 +01:00
|
|
|
Operator tup;
|
|
|
|
Form_pg_operator opform;
|
|
|
|
Node *left,
|
|
|
|
*right;
|
|
|
|
|
2003-01-10 22:08:15 +01:00
|
|
|
Assert(!te->resdom->resjunk);
|
|
|
|
|
2003-01-20 19:55:07 +01:00
|
|
|
if (rtindex)
|
|
|
|
{
|
|
|
|
/* Make the Var node representing the subplan's result */
|
|
|
|
rightop = (Node *) makeVar(rtindex,
|
|
|
|
te->resdom->resno,
|
|
|
|
te->resdom->restype,
|
|
|
|
te->resdom->restypmod,
|
|
|
|
0);
|
|
|
|
/* Record it for caller */
|
|
|
|
*righthandIds = lappend(*righthandIds, rightop);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Make the Param node representing the subplan's result */
|
|
|
|
Param *prm;
|
|
|
|
|
|
|
|
prm = generate_new_param(te->resdom->restype,
|
|
|
|
te->resdom->restypmod);
|
|
|
|
/* Record its ID */
|
|
|
|
*righthandIds = lappendi(*righthandIds, prm->paramid);
|
|
|
|
rightop = (Node *) prm;
|
|
|
|
}
|
2002-11-26 04:01:59 +01:00
|
|
|
|
2003-01-10 22:08:15 +01:00
|
|
|
/* Look up the operator to get its declared input types */
|
2002-11-26 04:01:59 +01:00
|
|
|
tup = SearchSysCache(OPEROID,
|
2003-01-10 22:08:15 +01:00
|
|
|
ObjectIdGetDatum(opid),
|
2002-11-26 04:01:59 +01:00
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tup))
|
2003-01-10 22:08:15 +01:00
|
|
|
elog(ERROR, "cache lookup failed for operator %u", opid);
|
2002-11-26 04:01:59 +01:00
|
|
|
opform = (Form_pg_operator) GETSTRUCT(tup);
|
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
/*
|
2002-11-26 04:01:59 +01:00
|
|
|
* Make the expression node.
|
|
|
|
*
|
|
|
|
* Note: we use make_operand in case runtime type conversion
|
|
|
|
* function calls must be inserted for this operator!
|
1999-08-26 01:21:43 +02:00
|
|
|
*/
|
2002-12-14 01:17:59 +01:00
|
|
|
left = make_operand(leftop, exprType(leftop), opform->oprleft);
|
2003-01-20 19:55:07 +01:00
|
|
|
right = make_operand(rightop, te->resdom->restype, opform->oprright);
|
2003-01-10 22:08:15 +01:00
|
|
|
result = lappend(result,
|
|
|
|
make_opclause(opid,
|
|
|
|
opform->oprresult,
|
|
|
|
false, /* set-result not allowed */
|
|
|
|
(Expr *) left,
|
|
|
|
(Expr *) right));
|
2000-04-12 19:17:23 +02:00
|
|
|
|
2002-11-26 04:01:59 +01:00
|
|
|
ReleaseSysCache(tup);
|
|
|
|
|
2003-01-10 22:08:15 +01:00
|
|
|
lefthand = lnext(lefthand);
|
2002-11-26 04:01:59 +01:00
|
|
|
targetlist = lnext(targetlist);
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2003-01-10 22:08:15 +01:00
|
|
|
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;
|
|
|
|
/*
|
2003-01-12 05:03:34 +01:00
|
|
|
* The combining operators must be hashable, strict, and self-commutative.
|
|
|
|
* The need for hashability is obvious, since we want to use hashing.
|
|
|
|
* 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.) And commutativity ensures
|
|
|
|
* that the left and right datatypes are the same; this allows us to
|
|
|
|
* assume that the combining operators are equality for the righthand
|
|
|
|
* datatype, so that they can be used to compare righthand tuples as
|
|
|
|
* well as comparing lefthand to righthand tuples. (This last restriction
|
|
|
|
* could be relaxed by using two different sets of operators with the
|
|
|
|
* hash table, but there is no obvious usefulness to that at present.)
|
2003-01-10 22:08:15 +01:00
|
|
|
*/
|
|
|
|
foreach(opids, slink->operOids)
|
|
|
|
{
|
2003-02-09 07:56:28 +01:00
|
|
|
Oid opid = lfirsto(opids);
|
2003-01-10 22:08:15 +01:00
|
|
|
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);
|
2003-01-12 05:03:34 +01:00
|
|
|
if (!optup->oprcanhash || optup->oprcom != opid ||
|
|
|
|
!func_strict(optup->oprcode))
|
2003-01-10 22:08:15 +01:00
|
|
|
{
|
|
|
|
ReleaseSysCache(tup);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
ReleaseSysCache(tup);
|
|
|
|
}
|
|
|
|
return true;
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
|
|
|
|
2003-01-20 19:55:07 +01:00
|
|
|
/*
|
|
|
|
* convert_IN_to_join: can we convert an IN SubLink to join style?
|
|
|
|
*
|
|
|
|
* The caller has found a SubLink at the top level of WHERE, but has not
|
|
|
|
* checked the properties of the SubLink at all. Decide whether it is
|
|
|
|
* appropriate to process this SubLink in join style. If not, return NULL.
|
|
|
|
* If so, build the qual clause(s) to replace the SubLink, and return them.
|
|
|
|
*
|
|
|
|
* Side effects of a successful conversion include adding the SubLink's
|
|
|
|
* subselect to the query's rangetable and adding an InClauseInfo node to
|
|
|
|
* its in_info_list.
|
|
|
|
*/
|
|
|
|
Node *
|
|
|
|
convert_IN_to_join(Query *parse, SubLink *sublink)
|
|
|
|
{
|
|
|
|
Query *subselect = (Query *) sublink->subselect;
|
2003-02-08 21:20:55 +01:00
|
|
|
Relids left_varnos;
|
2003-01-20 19:55:07 +01:00
|
|
|
int rtindex;
|
|
|
|
RangeTblEntry *rte;
|
|
|
|
RangeTblRef *rtr;
|
|
|
|
InClauseInfo *ininfo;
|
|
|
|
List *exprs;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.)
|
|
|
|
*/
|
|
|
|
if (sublink->subLinkType != ANY_SUBLINK)
|
|
|
|
return NULL;
|
|
|
|
if (length(sublink->operName) != 1 ||
|
|
|
|
strcmp(strVal(lfirst(sublink->operName)), "=") != 0)
|
|
|
|
return NULL;
|
|
|
|
/*
|
|
|
|
* The sub-select must not refer to any Vars of the parent query.
|
|
|
|
* (Vars of higher levels should be okay, though.)
|
|
|
|
*/
|
|
|
|
if (contain_vars_of_level((Node *) subselect, 1))
|
|
|
|
return NULL;
|
|
|
|
/*
|
|
|
|
* The left-hand expressions must contain some Vars of the current
|
|
|
|
* query, else it's not gonna be a join.
|
|
|
|
*/
|
|
|
|
left_varnos = pull_varnos((Node *) sublink->lefthand);
|
2003-02-08 21:20:55 +01:00
|
|
|
if (bms_is_empty(left_varnos))
|
2003-01-20 19:55:07 +01:00
|
|
|
return NULL;
|
|
|
|
/*
|
|
|
|
* The left-hand expressions mustn't be volatile. (Perhaps we should
|
|
|
|
* test the combining operators, too? We'd only need to point the
|
|
|
|
* function directly at the sublink ...)
|
|
|
|
*/
|
|
|
|
if (contain_volatile_functions((Node *) sublink->lefthand))
|
|
|
|
return NULL;
|
|
|
|
/*
|
|
|
|
* Okay, pull up the sub-select into top range table and jointree.
|
|
|
|
*
|
|
|
|
* We rely here on the assumption that the outer query has no references
|
|
|
|
* to the inner (necessarily true, other than the Vars that we build
|
|
|
|
* below). Therefore this is a lot easier than what pull_up_subqueries
|
|
|
|
* has to go through.
|
|
|
|
*/
|
|
|
|
rte = addRangeTableEntryForSubquery(NULL,
|
|
|
|
subselect,
|
|
|
|
makeAlias("IN_subquery", NIL),
|
|
|
|
false);
|
|
|
|
parse->rtable = lappend(parse->rtable, rte);
|
|
|
|
rtindex = length(parse->rtable);
|
|
|
|
rtr = makeNode(RangeTblRef);
|
|
|
|
rtr->rtindex = rtindex;
|
|
|
|
parse->jointree->fromlist = lappend(parse->jointree->fromlist, rtr);
|
|
|
|
/*
|
|
|
|
* Now build the InClauseInfo node.
|
|
|
|
*/
|
|
|
|
ininfo = makeNode(InClauseInfo);
|
|
|
|
ininfo->lefthand = left_varnos;
|
2003-02-08 21:20:55 +01:00
|
|
|
ininfo->righthand = bms_make_singleton(rtindex);
|
2003-01-20 19:55:07 +01:00
|
|
|
parse->in_info_list = lcons(ininfo, parse->in_info_list);
|
|
|
|
/*
|
|
|
|
* Build the result qual expressions. As a side effect,
|
|
|
|
* ininfo->sub_targetlist is filled with a list of the Vars
|
|
|
|
* representing the subselect outputs.
|
|
|
|
*/
|
|
|
|
exprs = convert_sublink_opers(sublink->lefthand,
|
|
|
|
sublink->operOids,
|
|
|
|
subselect->targetList,
|
|
|
|
rtindex,
|
|
|
|
&ininfo->sub_targetlist);
|
|
|
|
return (Node *) make_ands_explicit(exprs);
|
|
|
|
}
|
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
/*
|
|
|
|
* Replace correlation vars (uplevel vars) with Params.
|
1999-07-15 03:52:09 +02:00
|
|
|
*/
|
1998-02-13 04:37:04 +01:00
|
|
|
Node *
|
1998-02-26 05:46:47 +01:00
|
|
|
SS_replace_correlation_vars(Node *expr)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
1999-08-26 01:21:43 +02:00
|
|
|
/* No setup needed for tree walk, so away we go */
|
|
|
|
return replace_correlation_vars_mutator(expr, NULL);
|
|
|
|
}
|
1999-07-15 03:52:09 +02:00
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
static Node *
|
|
|
|
replace_correlation_vars_mutator(Node *node, void *context)
|
|
|
|
{
|
|
|
|
if (node == NULL)
|
|
|
|
return NULL;
|
|
|
|
if (IsA(node, Var))
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
1999-08-26 01:21:43 +02:00
|
|
|
if (((Var *) node)->varlevelsup > 0)
|
|
|
|
return (Node *) replace_var((Var *) node);
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
1999-08-26 01:21:43 +02:00
|
|
|
return expression_tree_mutator(node,
|
|
|
|
replace_correlation_vars_mutator,
|
|
|
|
context);
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
/*
|
|
|
|
* Expand SubLinks to SubPlans in the given expression.
|
2003-01-13 19:10:53 +01:00
|
|
|
*
|
|
|
|
* The isQual argument tells whether or not this expression is a WHERE/HAVING
|
|
|
|
* qualifier expression. If it is, any sublinks appearing at top level need
|
|
|
|
* not distinguish FALSE from UNKNOWN return values.
|
1999-07-15 03:52:09 +02:00
|
|
|
*/
|
1998-02-26 05:46:47 +01:00
|
|
|
Node *
|
2003-01-13 19:10:53 +01:00
|
|
|
SS_process_sublinks(Node *expr, bool isQual)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2003-01-13 19:10:53 +01:00
|
|
|
/* The only context needed is the initial are-we-in-a-qual flag */
|
|
|
|
return process_sublinks_mutator(expr, &isQual);
|
1999-08-26 01:21:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static Node *
|
2003-01-13 19:10:53 +01:00
|
|
|
process_sublinks_mutator(Node *node, bool *isTopQual)
|
1999-08-26 01:21:43 +02:00
|
|
|
{
|
2003-01-13 19:10:53 +01:00
|
|
|
bool locTopQual;
|
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
if (node == NULL)
|
1998-09-01 05:29:17 +02:00
|
|
|
return NULL;
|
1999-08-26 01:21:43 +02:00
|
|
|
if (IsA(node, SubLink))
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
SubLink *sublink = (SubLink *) node;
|
2002-12-14 01:17:59 +01:00
|
|
|
List *lefthand;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
/*
|
2002-12-14 01:17:59 +01:00
|
|
|
* First, recursively process the lefthand-side expressions, if any.
|
1999-07-15 03:52:09 +02:00
|
|
|
*/
|
2003-01-13 19:10:53 +01:00
|
|
|
locTopQual = false;
|
2002-12-14 01:17:59 +01:00
|
|
|
lefthand = (List *)
|
2003-01-13 19:10:53 +01:00
|
|
|
process_sublinks_mutator((Node *) sublink->lefthand, &locTopQual);
|
2002-12-14 01:17:59 +01:00
|
|
|
/*
|
|
|
|
* Now build the SubPlan node and make the expr to return.
|
|
|
|
*/
|
2003-01-13 19:10:53 +01:00
|
|
|
return make_subplan(sublink, lefthand, *isTopQual);
|
1999-07-15 03:52:09 +02:00
|
|
|
}
|
2000-04-12 19:17:23 +02:00
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
/*
|
2003-01-17 03:01:21 +01:00
|
|
|
* We should never see a SubPlan expression in the input (since this is
|
|
|
|
* the very routine that creates 'em to begin with). We shouldn't find
|
|
|
|
* ourselves invoked directly on a Query, either.
|
1999-08-26 01:21:43 +02:00
|
|
|
*/
|
2000-04-12 19:17:23 +02:00
|
|
|
Assert(!is_subplan(node));
|
2003-01-17 03:01:21 +01:00
|
|
|
Assert(!IsA(node, Query));
|
1998-09-01 06:40:42 +02:00
|
|
|
|
2003-01-13 19:10:53 +01:00
|
|
|
/*
|
|
|
|
* If we recurse down through anything other than a List node, we are
|
|
|
|
* definitely not at top qual level anymore.
|
|
|
|
*/
|
|
|
|
if (IsA(node, List))
|
|
|
|
locTopQual = *isTopQual;
|
|
|
|
else
|
|
|
|
locTopQual = false;
|
|
|
|
|
1999-08-26 01:21:43 +02:00
|
|
|
return expression_tree_mutator(node,
|
|
|
|
process_sublinks_mutator,
|
2003-01-13 19:10:53 +01:00
|
|
|
(void *) &locTopQual);
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
|
|
|
|
2002-12-14 01:17:59 +01:00
|
|
|
/*
|
|
|
|
* SS_finalize_plan - do final sublink processing for a completed Plan.
|
|
|
|
*
|
2003-02-09 01:30:41 +01:00
|
|
|
* This recursively computes the extParam and allParam sets
|
|
|
|
* for every Plan node in the given plan tree.
|
2002-12-14 01:17:59 +01:00
|
|
|
*/
|
2003-02-09 01:30:41 +01:00
|
|
|
void
|
2002-05-18 20:49:41 +02:00
|
|
|
SS_finalize_plan(Plan *plan, List *rtable)
|
1998-02-13 04:37:04 +01:00
|
|
|
{
|
2003-02-09 01:30:41 +01:00
|
|
|
Bitmapset *outer_params = NULL;
|
|
|
|
Bitmapset *valid_params = NULL;
|
|
|
|
int paramid;
|
|
|
|
List *lst;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First, scan the param list to discover the sets of params that
|
|
|
|
* are available from outer query levels and my own query level.
|
|
|
|
* We do this once to save time in the per-plan recursion steps.
|
|
|
|
*/
|
|
|
|
paramid = 0;
|
|
|
|
foreach(lst, PlannerParamVar)
|
|
|
|
{
|
|
|
|
Var *var = (Var *) lfirst(lst);
|
|
|
|
|
|
|
|
/* note varlevelsup is absolute level number */
|
|
|
|
if (var->varlevelsup < PlannerQueryLevel)
|
|
|
|
{
|
|
|
|
/* valid outer-level parameter */
|
|
|
|
outer_params = bms_add_member(outer_params, paramid);
|
|
|
|
valid_params = bms_add_member(valid_params, paramid);
|
|
|
|
}
|
|
|
|
else if (var->varlevelsup == PlannerQueryLevel &&
|
|
|
|
var->varno == 0 && var->varattno == 0)
|
|
|
|
{
|
|
|
|
/* valid local parameter (i.e., a setParam of my child) */
|
|
|
|
valid_params = bms_add_member(valid_params, paramid);
|
|
|
|
}
|
|
|
|
|
|
|
|
paramid++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now recurse through plan tree.
|
|
|
|
*/
|
|
|
|
(void) finalize_plan(plan, rtable, outer_params, valid_params);
|
|
|
|
|
|
|
|
bms_free(outer_params);
|
|
|
|
bms_free(valid_params);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Recursive processing of all nodes in the plan tree
|
|
|
|
*
|
|
|
|
* The return value is the computed allParam set for the given Plan node.
|
|
|
|
* This is just an internal notational convenience.
|
|
|
|
*/
|
|
|
|
static Bitmapset *
|
|
|
|
finalize_plan(Plan *plan, List *rtable,
|
|
|
|
Bitmapset *outer_params, Bitmapset *valid_params)
|
|
|
|
{
|
|
|
|
finalize_primnode_context context;
|
1998-02-26 05:46:47 +01:00
|
|
|
List *lst;
|
|
|
|
|
|
|
|
if (plan == NULL)
|
2003-02-09 01:30:41 +01:00
|
|
|
return NULL;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
context.paramids = NULL; /* initialize set to empty */
|
|
|
|
context.outer_params = outer_params;
|
2000-04-12 19:17:23 +02:00
|
|
|
|
1999-11-15 03:00:15 +01:00
|
|
|
/*
|
2003-02-09 01:30:41 +01:00
|
|
|
* When we call finalize_primnode, context.paramids sets are
|
2000-04-12 19:17:23 +02:00
|
|
|
* automatically merged together. But when recursing to self, we have
|
2003-02-09 01:30:41 +01:00
|
|
|
* to do it the hard way. We want the paramids set to include params
|
2002-12-05 16:50:39 +01:00
|
|
|
* in subplans as well as at this level.
|
1999-11-15 03:00:15 +01:00
|
|
|
*/
|
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
/* Find params in targetlist and qual */
|
2003-02-09 01:30:41 +01:00
|
|
|
finalize_primnode((Node *) plan->targetlist, &context);
|
|
|
|
finalize_primnode((Node *) plan->qual, &context);
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1999-11-15 03:00:15 +01:00
|
|
|
/* Check additional node-type-specific fields */
|
1998-02-13 04:37:04 +01:00
|
|
|
switch (nodeTag(plan))
|
|
|
|
{
|
|
|
|
case T_Result:
|
1999-11-15 03:00:15 +01:00
|
|
|
finalize_primnode(((Result *) plan)->resconstantqual,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
1998-02-13 04:37:04 +01:00
|
|
|
break;
|
|
|
|
|
2002-05-18 20:49:41 +02:00
|
|
|
case T_IndexScan:
|
|
|
|
finalize_primnode((Node *) ((IndexScan *) plan)->indxqual,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
2002-05-18 20:49:41 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we need not look at indxqualorig, since it will have the
|
2002-12-05 16:50:39 +01:00
|
|
|
* same param references as indxqual.
|
2002-05-18 20:49:41 +02:00
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_TidScan:
|
|
|
|
finalize_primnode((Node *) ((TidScan *) plan)->tideval,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
1998-02-13 04:37:04 +01:00
|
|
|
break;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-10-05 21:11:39 +02:00
|
|
|
case T_SubqueryScan:
|
2001-03-22 05:01:46 +01:00
|
|
|
|
2000-11-21 01:17:59 +01:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* In a SubqueryScan, SS_finalize_plan has already been run on
|
|
|
|
* the subplan by the inner invocation of subquery_planner, so
|
|
|
|
* there's no need to do it again. Instead, just pull out the
|
|
|
|
* subplan's extParams list, which represents the params it
|
|
|
|
* needs from my level and higher levels.
|
2000-11-21 01:17:59 +01:00
|
|
|
*/
|
2003-02-09 01:30:41 +01:00
|
|
|
context.paramids = bms_add_members(context.paramids,
|
2001-03-22 05:01:46 +01:00
|
|
|
((SubqueryScan *) plan)->subplan->extParam);
|
2000-10-05 21:11:39 +02:00
|
|
|
break;
|
|
|
|
|
2002-05-18 20:49:41 +02:00
|
|
|
case T_FunctionScan:
|
|
|
|
{
|
|
|
|
RangeTblEntry *rte;
|
2000-04-12 19:17:23 +02:00
|
|
|
|
2002-05-18 20:49:41 +02:00
|
|
|
rte = rt_fetch(((FunctionScan *) plan)->scan.scanrelid,
|
|
|
|
rtable);
|
|
|
|
Assert(rte->rtekind == RTE_FUNCTION);
|
2003-02-09 01:30:41 +01:00
|
|
|
finalize_primnode(rte->funcexpr, &context);
|
2002-05-18 20:49:41 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Append:
|
|
|
|
foreach(lst, ((Append *) plan)->appendplans)
|
2003-02-09 01:30:41 +01:00
|
|
|
{
|
|
|
|
context.paramids =
|
|
|
|
bms_add_members(context.paramids,
|
|
|
|
finalize_plan((Plan *) lfirst(lst),
|
|
|
|
rtable,
|
|
|
|
outer_params,
|
|
|
|
valid_params));
|
|
|
|
}
|
1998-02-13 04:37:04 +01:00
|
|
|
break;
|
|
|
|
|
2000-09-12 23:07:18 +02:00
|
|
|
case T_NestLoop:
|
|
|
|
finalize_primnode((Node *) ((Join *) plan)->joinqual,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
2000-09-12 23:07:18 +02:00
|
|
|
break;
|
|
|
|
|
1998-02-13 04:37:04 +01:00
|
|
|
case T_MergeJoin:
|
2000-09-12 23:07:18 +02:00
|
|
|
finalize_primnode((Node *) ((Join *) plan)->joinqual,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
1999-11-15 03:00:15 +01:00
|
|
|
finalize_primnode((Node *) ((MergeJoin *) plan)->mergeclauses,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
1998-02-13 04:37:04 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case T_HashJoin:
|
2000-09-12 23:07:18 +02:00
|
|
|
finalize_primnode((Node *) ((Join *) plan)->joinqual,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
1999-11-15 03:00:15 +01:00
|
|
|
finalize_primnode((Node *) ((HashJoin *) plan)->hashclauses,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
1998-02-13 04:37:04 +01:00
|
|
|
break;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1998-02-13 04:37:04 +01:00
|
|
|
case T_Hash:
|
2002-11-30 01:08:22 +01:00
|
|
|
finalize_primnode((Node *) ((Hash *) plan)->hashkeys,
|
2003-02-09 01:30:41 +01:00
|
|
|
&context);
|
1998-02-13 04:37:04 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Agg:
|
|
|
|
case T_SeqScan:
|
|
|
|
case T_Material:
|
|
|
|
case T_Sort:
|
|
|
|
case T_Unique:
|
2000-10-05 21:11:39 +02:00
|
|
|
case T_SetOp:
|
2000-10-26 23:38:24 +02:00
|
|
|
case T_Limit:
|
1998-02-13 04:37:04 +01:00
|
|
|
case T_Group:
|
|
|
|
break;
|
1999-07-15 03:52:09 +02:00
|
|
|
|
1998-02-13 04:37:04 +01:00
|
|
|
default:
|
2003-02-09 01:30:41 +01:00
|
|
|
elog(ERROR, "finalize_plan: node %d unsupported",
|
1999-07-15 03:52:09 +02:00
|
|
|
nodeTag(plan));
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
/* Process left and right child plans, if any */
|
2003-02-09 01:30:41 +01:00
|
|
|
context.paramids = bms_add_members(context.paramids,
|
|
|
|
finalize_plan(plan->lefttree,
|
|
|
|
rtable,
|
|
|
|
outer_params,
|
|
|
|
valid_params));
|
|
|
|
|
|
|
|
context.paramids = bms_add_members(context.paramids,
|
|
|
|
finalize_plan(plan->righttree,
|
|
|
|
rtable,
|
|
|
|
outer_params,
|
|
|
|
valid_params));
|
1999-07-15 03:52:09 +02:00
|
|
|
|
2002-12-05 16:50:39 +01:00
|
|
|
/* Now we have all the paramids */
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
if (!bms_is_subset(context.paramids, valid_params))
|
|
|
|
elog(ERROR, "finalize_plan: plan shouldn't reference subplan's variable");
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
plan->extParam = bms_intersect(context.paramids, outer_params);
|
|
|
|
plan->allParam = context.paramids;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
/*
|
|
|
|
* For speed at execution time, make sure extParam/allParam are actually
|
|
|
|
* NULL if they are empty sets.
|
|
|
|
*/
|
|
|
|
if (bms_is_empty(plan->extParam))
|
|
|
|
{
|
|
|
|
bms_free(plan->extParam);
|
|
|
|
plan->extParam = NULL;
|
|
|
|
}
|
|
|
|
if (bms_is_empty(plan->allParam))
|
|
|
|
{
|
|
|
|
bms_free(plan->allParam);
|
|
|
|
plan->allParam = NULL;
|
|
|
|
}
|
1998-02-13 04:37:04 +01:00
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
return plan->allParam;
|
1998-02-13 04:37:04 +01:00
|
|
|
}
|
2002-12-14 01:17:59 +01:00
|
|
|
|
|
|
|
/*
|
2003-02-09 01:30:41 +01:00
|
|
|
* finalize_primnode: add IDs of all PARAM_EXEC params appearing in the given
|
|
|
|
* expression tree to the result set.
|
2002-12-14 01:17:59 +01:00
|
|
|
*/
|
|
|
|
static bool
|
2003-02-09 01:30:41 +01:00
|
|
|
finalize_primnode(Node *node, finalize_primnode_context *context)
|
2002-12-14 01:17:59 +01:00
|
|
|
{
|
|
|
|
if (node == NULL)
|
|
|
|
return false;
|
|
|
|
if (IsA(node, Param))
|
|
|
|
{
|
|
|
|
if (((Param *) node)->paramkind == PARAM_EXEC)
|
|
|
|
{
|
|
|
|
int paramid = (int) ((Param *) node)->paramid;
|
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
context->paramids = bms_add_member(context->paramids, paramid);
|
2002-12-14 01:17:59 +01:00
|
|
|
}
|
|
|
|
return false; /* no more to do here */
|
|
|
|
}
|
|
|
|
if (is_subplan(node))
|
|
|
|
{
|
|
|
|
SubPlan *subplan = (SubPlan *) node;
|
|
|
|
|
2003-02-09 01:30:41 +01:00
|
|
|
/* Add outer-level params needed by the subplan to paramids */
|
|
|
|
context->paramids = bms_join(context->paramids,
|
|
|
|
bms_intersect(subplan->plan->extParam,
|
|
|
|
context->outer_params));
|
2002-12-14 01:17:59 +01:00
|
|
|
/* fall through to recurse into subplan args */
|
|
|
|
}
|
|
|
|
return expression_tree_walker(node, finalize_primnode,
|
2003-02-09 01:30:41 +01:00
|
|
|
(void *) context);
|
2002-12-14 01:17:59 +01:00
|
|
|
}
|