mirror of
https://github.com/postgres/postgres.git
synced 2025-04-22 23:02:54 +03:00
Revise implementation of SubLinks so that there is a consistent,
documented intepretation of the lefthand and oper fields. Fix a number of obscure problems while at it --- for example, the old code failed if the parser decided to insert a type-coercion function just below the operator of a SubLink. CAUTION: this will break stored rules that contain subplans. You may need to initdb.
This commit is contained in:
Tom Lane
parent
edda70c0de
commit
42af56e1ea
@ -94,8 +94,25 @@ ExecSubPlan(SubPlan *node, List *pvar, ExprContext *econtext)
|
||||
Const *con = lsecond(expr->args);
|
||||
bool isnull;
|
||||
|
||||
/*
|
||||
* The righthand side of the expression should be either a Const
|
||||
* or a function call taking a Const as arg (the function would
|
||||
* be a run-time type coercion inserted by the parser to get to
|
||||
* the input type needed by the operator). Find the Const node
|
||||
* and insert the actual righthand side value into it.
|
||||
*/
|
||||
if (! IsA(con, Const))
|
||||
{
|
||||
Assert(IsA(con, Expr));
|
||||
con = lfirst(((Expr *) con)->args);
|
||||
Assert(IsA(con, Const));
|
||||
}
|
||||
con->constvalue = heap_getattr(tup, i, tdesc, &(con->constisnull));
|
||||
result = ExecEvalExpr((Node *) expr, econtext, &isnull, (bool *) NULL);
|
||||
/*
|
||||
* Now we can eval the expression.
|
||||
*/
|
||||
result = ExecEvalExpr((Node *) expr, econtext, &isnull,
|
||||
(bool *) NULL);
|
||||
if (isnull)
|
||||
{
|
||||
if (subLinkType == EXPR_SUBLINK)
|
||||
|
||||
@ -6,18 +6,24 @@
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.23 1999/08/22 20:14:49 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.24 1999/08/25 23:21:39 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include "catalog/pg_operator.h"
|
||||
#include "catalog/pg_type.h"
|
||||
#include "nodes/makefuncs.h"
|
||||
#include "nodes/nodeFuncs.h"
|
||||
#include "optimizer/clauses.h"
|
||||
#include "optimizer/planner.h"
|
||||
#include "optimizer/subselect.h"
|
||||
#include "parser/parse_expr.h"
|
||||
#include "parser/parse_node.h"
|
||||
#include "parser/parse_oper.h"
|
||||
#include "utils/lsyscache.h"
|
||||
|
||||
|
||||
int PlannerQueryLevel; /* level of current query */
|
||||
List *PlannerInitPlan; /* init subplans for current query */
|
||||
@ -46,7 +52,7 @@ int PlannerPlanId; /* to assign unique ID to subquery plans */
|
||||
* is set from the absolute level value given by varlevel.
|
||||
*/
|
||||
static int
|
||||
_new_param(Var *var, int varlevel)
|
||||
new_param(Var *var, int varlevel)
|
||||
{
|
||||
Var *paramVar = (Var *) copyObject(var);
|
||||
|
||||
@ -62,7 +68,7 @@ _new_param(Var *var, int varlevel)
|
||||
* which is expected to have varlevelsup > 0 (ie, it is not local).
|
||||
*/
|
||||
static Param *
|
||||
_replace_var(Var *var)
|
||||
replace_var(Var *var)
|
||||
{
|
||||
List *ppv;
|
||||
Param *retval;
|
||||
@ -98,7 +104,7 @@ _replace_var(Var *var)
|
||||
if (! ppv)
|
||||
{
|
||||
/* Nope, so make a new one */
|
||||
i = _new_param(var, varlevel);
|
||||
i = new_param(var, varlevel);
|
||||
}
|
||||
|
||||
retval = makeNode(Param);
|
||||
@ -109,8 +115,11 @@ _replace_var(Var *var)
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert a bare SubLink (as created by the parser) into a SubPlan.
|
||||
*/
|
||||
static Node *
|
||||
_make_subplan(SubLink *slink)
|
||||
make_subplan(SubLink *slink)
|
||||
{
|
||||
SubPlan *node = makeNode(SubPlan);
|
||||
Plan *plan;
|
||||
@ -126,7 +135,7 @@ _make_subplan(SubLink *slink)
|
||||
|
||||
/*
|
||||
* Assign subPlan, extParam and locParam to plan nodes. At the moment,
|
||||
* SS_finalize_plan doesn't handle initPlan-s and so we assigne them
|
||||
* SS_finalize_plan doesn't handle initPlan-s and so we assign them
|
||||
* to the topmost plan node and take care about its extParam too.
|
||||
*/
|
||||
(void) SS_finalize_plan(plan);
|
||||
@ -169,31 +178,58 @@ _make_subplan(SubLink *slink)
|
||||
*/
|
||||
if (node->parParam == NULL && slink->subLinkType == EXPR_SUBLINK)
|
||||
{
|
||||
List *newoper = NIL;
|
||||
int i = 0;
|
||||
|
||||
/* transform right side of all sublink Oper-s into Param */
|
||||
/*
|
||||
* Convert oper list of Opers into a list of Exprs, using
|
||||
* lefthand arguments and Params representing inside results.
|
||||
*/
|
||||
foreach(lst, slink->oper)
|
||||
{
|
||||
List *rside = lnext(((Expr *) lfirst(lst))->args);
|
||||
Oper *oper = (Oper *) lfirst(lst);
|
||||
Node *lefthand = nth(i, slink->lefthand);
|
||||
TargetEntry *te = nth(i, plan->targetlist);
|
||||
/* need a var node just to pass to new_param()... */
|
||||
Var *var = makeVar(0, 0, te->resdom->restype,
|
||||
te->resdom->restypmod, 0);
|
||||
Param *prm = makeNode(Param);
|
||||
Operator tup;
|
||||
Form_pg_operator opform;
|
||||
Node *left,
|
||||
*right;
|
||||
|
||||
prm->paramkind = PARAM_EXEC;
|
||||
prm->paramid = (AttrNumber) _new_param(var, PlannerQueryLevel);
|
||||
prm->paramid = (AttrNumber) new_param(var, PlannerQueryLevel);
|
||||
prm->paramtype = var->vartype;
|
||||
lfirst(rside) = prm;
|
||||
|
||||
Assert(IsA(oper, Oper));
|
||||
tup = get_operator_tuple(oper->opno);
|
||||
Assert(HeapTupleIsValid(tup));
|
||||
opform = (Form_pg_operator) GETSTRUCT(tup);
|
||||
/* Note: we use make_operand in case runtime type conversion
|
||||
* function calls must be inserted for this operator!
|
||||
*/
|
||||
left = make_operand("", lefthand,
|
||||
exprType(lefthand), opform->oprleft);
|
||||
right = make_operand("", (Node *) prm,
|
||||
prm->paramtype, opform->oprright);
|
||||
newoper = lappend(newoper,
|
||||
make_opclause(oper,
|
||||
(Var *) left,
|
||||
(Var *) right));
|
||||
node->setParam = lappendi(node->setParam, prm->paramid);
|
||||
pfree(var);
|
||||
i++;
|
||||
}
|
||||
slink->oper = newoper;
|
||||
slink->lefthand = NIL;
|
||||
PlannerInitPlan = lappend(PlannerInitPlan, node);
|
||||
if (i > 1)
|
||||
result = (Node *) ((slink->useor) ? make_orclause(slink->oper) :
|
||||
make_andclause(slink->oper));
|
||||
result = (Node *) ((slink->useor) ? make_orclause(newoper) :
|
||||
make_andclause(newoper));
|
||||
else
|
||||
result = (Node *) lfirst(slink->oper);
|
||||
result = (Node *) lfirst(newoper);
|
||||
}
|
||||
else if (node->parParam == NULL && slink->subLinkType == EXISTS_SUBLINK)
|
||||
{
|
||||
@ -201,7 +237,7 @@ _make_subplan(SubLink *slink)
|
||||
Param *prm = makeNode(Param);
|
||||
|
||||
prm->paramkind = PARAM_EXEC;
|
||||
prm->paramid = (AttrNumber) _new_param(var, PlannerQueryLevel);
|
||||
prm->paramid = (AttrNumber) new_param(var, PlannerQueryLevel);
|
||||
prm->paramtype = var->vartype;
|
||||
node->setParam = lappendi(node->setParam, prm->paramid);
|
||||
pfree(var);
|
||||
@ -213,16 +249,15 @@ _make_subplan(SubLink *slink)
|
||||
/* make expression of SUBPLAN type */
|
||||
Expr *expr = makeNode(Expr);
|
||||
List *args = NIL;
|
||||
List *newoper = NIL;
|
||||
int i = 0;
|
||||
|
||||
expr->typeOid = BOOLOID;
|
||||
expr->typeOid = BOOLOID; /* bogus, but we don't really care */
|
||||
expr->opType = SUBPLAN_EXPR;
|
||||
expr->oper = (Node *) node;
|
||||
|
||||
/*
|
||||
* Make expr->args from parParam. Left sides of sublink Oper-s are
|
||||
* handled by optimizer directly... Also, transform right side of
|
||||
* sublink Oper-s into Const.
|
||||
* Make expr->args from parParam.
|
||||
*/
|
||||
foreach(lst, node->parParam)
|
||||
{
|
||||
@ -236,23 +271,55 @@ _make_subplan(SubLink *slink)
|
||||
var->varlevelsup = 0;
|
||||
args = lappend(args, var);
|
||||
}
|
||||
expr->args = args;
|
||||
/*
|
||||
* Convert oper list of Opers into a list of Exprs, using
|
||||
* lefthand arguments and Consts representing inside results.
|
||||
*/
|
||||
foreach(lst, slink->oper)
|
||||
{
|
||||
List *rside = lnext(((Expr *) lfirst(lst))->args);
|
||||
Oper *oper = (Oper *) lfirst(lst);
|
||||
Node *lefthand = nth(i, slink->lefthand);
|
||||
TargetEntry *te = nth(i, plan->targetlist);
|
||||
Const *con = makeConst(te->resdom->restype,
|
||||
0, 0, true, 0, 0, 0);
|
||||
Const *con;
|
||||
Operator tup;
|
||||
Form_pg_operator opform;
|
||||
Node *left,
|
||||
*right;
|
||||
|
||||
lfirst(rside) = con;
|
||||
/*
|
||||
* XXX really ought to fill in constlen and constbyval correctly,
|
||||
* but right now ExecEvalExpr won't look at them...
|
||||
*/
|
||||
con = makeConst(te->resdom->restype, 0, 0, true, 0, 0, 0);
|
||||
|
||||
Assert(IsA(oper, Oper));
|
||||
tup = get_operator_tuple(oper->opno);
|
||||
Assert(HeapTupleIsValid(tup));
|
||||
opform = (Form_pg_operator) GETSTRUCT(tup);
|
||||
/* Note: we use make_operand in case runtime type conversion
|
||||
* function calls must be inserted for this operator!
|
||||
*/
|
||||
left = make_operand("", lefthand,
|
||||
exprType(lefthand), opform->oprleft);
|
||||
right = make_operand("", (Node *) con,
|
||||
con->consttype, opform->oprright);
|
||||
newoper = lappend(newoper,
|
||||
make_opclause(oper,
|
||||
(Var *) left,
|
||||
(Var *) right));
|
||||
i++;
|
||||
}
|
||||
expr->args = args;
|
||||
slink->oper = newoper;
|
||||
slink->lefthand = NIL;
|
||||
result = (Node *) expr;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* this oughta be merged with LispUnioni */
|
||||
|
||||
static List *
|
||||
set_unioni(List *l1, List *l2)
|
||||
{
|
||||
@ -264,6 +331,11 @@ set_unioni(List *l1, List *l2)
|
||||
return nconc(l1, set_differencei(l2, l1));
|
||||
}
|
||||
|
||||
/*
|
||||
* finalize_primnode: build lists of subplans and params appearing
|
||||
* in the given expression tree.
|
||||
*/
|
||||
|
||||
typedef struct finalize_primnode_results {
|
||||
List *subplans; /* List of subplans found in expr */
|
||||
List *paramids; /* List of PARAM_EXEC paramids found */
|
||||
@ -315,165 +387,83 @@ finalize_primnode_walker(Node *node,
|
||||
! intMember(paramid, results->paramids))
|
||||
results->paramids = lconsi(paramid, results->paramids);
|
||||
}
|
||||
/* XXX We do NOT allow expression_tree_walker to examine the args
|
||||
* passed to the subplan. Is that correct??? It's what the
|
||||
* old code did, but it seems mighty bogus... tgl 7/14/99
|
||||
*/
|
||||
return false; /* don't recurse into subplan args */
|
||||
/* fall through to recurse into subplan args */
|
||||
}
|
||||
return expression_tree_walker(node, finalize_primnode_walker,
|
||||
(void *) results);
|
||||
}
|
||||
|
||||
/* Replace correlation vars (uplevel vars) with Params. */
|
||||
|
||||
/* XXX should replace this with use of a generalized tree rebuilder,
|
||||
* designed along the same lines as expression_tree_walker.
|
||||
* Not done yet.
|
||||
/*
|
||||
* Replace correlation vars (uplevel vars) with Params.
|
||||
*/
|
||||
|
||||
static Node *replace_correlation_vars_mutator(Node *node, void *context);
|
||||
|
||||
Node *
|
||||
SS_replace_correlation_vars(Node *expr)
|
||||
{
|
||||
if (expr == NULL)
|
||||
return NULL;
|
||||
if (IsA(expr, Var))
|
||||
{
|
||||
if (((Var *) expr)->varlevelsup > 0)
|
||||
expr = (Node *) _replace_var((Var *) expr);
|
||||
}
|
||||
else if (single_node(expr))
|
||||
return expr;
|
||||
else if (IsA(expr, List))
|
||||
{
|
||||
List *le;
|
||||
|
||||
foreach(le, (List *) expr)
|
||||
lfirst(le) = SS_replace_correlation_vars((Node *) lfirst(le));
|
||||
}
|
||||
else if (IsA(expr, Expr))
|
||||
{
|
||||
/* XXX do we need to do anything special with subplans? */
|
||||
((Expr *) expr)->args = (List *)
|
||||
SS_replace_correlation_vars((Node *) ((Expr *) expr)->args);
|
||||
}
|
||||
else if (IsA(expr, Aggref))
|
||||
((Aggref *) expr)->target = SS_replace_correlation_vars(((Aggref *) expr)->target);
|
||||
else if (IsA(expr, Iter))
|
||||
((Iter *) expr)->iterexpr = SS_replace_correlation_vars(((Iter *) expr)->iterexpr);
|
||||
else if (IsA(expr, ArrayRef))
|
||||
{
|
||||
((ArrayRef *) expr)->refupperindexpr = (List *)
|
||||
SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->refupperindexpr);
|
||||
((ArrayRef *) expr)->reflowerindexpr = (List *)
|
||||
SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->reflowerindexpr);
|
||||
((ArrayRef *) expr)->refexpr = SS_replace_correlation_vars(((ArrayRef *) expr)->refexpr);
|
||||
((ArrayRef *) expr)->refassgnexpr = SS_replace_correlation_vars(((ArrayRef *) expr)->refassgnexpr);
|
||||
}
|
||||
else if (IsA(expr, CaseExpr))
|
||||
{
|
||||
CaseExpr *caseexpr = (CaseExpr *) expr;
|
||||
List *le;
|
||||
|
||||
foreach(le, caseexpr->args)
|
||||
{
|
||||
CaseWhen *when = (CaseWhen *) lfirst(le);
|
||||
Assert(IsA(when, CaseWhen));
|
||||
when->expr = SS_replace_correlation_vars(when->expr);
|
||||
when->result = SS_replace_correlation_vars(when->result);
|
||||
}
|
||||
/* caseexpr->arg should be null, but we'll check it anyway */
|
||||
caseexpr->arg = SS_replace_correlation_vars(caseexpr->arg);
|
||||
caseexpr->defresult = SS_replace_correlation_vars(caseexpr->defresult);
|
||||
}
|
||||
else if (IsA(expr, TargetEntry))
|
||||
((TargetEntry *) expr)->expr = SS_replace_correlation_vars(((TargetEntry *) expr)->expr);
|
||||
else if (IsA(expr, SubLink))
|
||||
{
|
||||
List *le;
|
||||
|
||||
foreach(le, ((SubLink *) expr)->oper) /* left sides only */
|
||||
{
|
||||
List *oparg = ((Expr *) lfirst(le))->args;
|
||||
|
||||
lfirst(oparg) = (List *)
|
||||
SS_replace_correlation_vars((Node *) lfirst(oparg));
|
||||
}
|
||||
((SubLink *) expr)->lefthand = (List *)
|
||||
SS_replace_correlation_vars((Node *) ((SubLink *) expr)->lefthand);
|
||||
}
|
||||
else
|
||||
elog(ERROR, "SS_replace_correlation_vars: can't handle node %d",
|
||||
nodeTag(expr));
|
||||
|
||||
return expr;
|
||||
/* No setup needed for tree walk, so away we go */
|
||||
return replace_correlation_vars_mutator(expr, NULL);
|
||||
}
|
||||
|
||||
/* Replace sublinks by subplans in the given expression */
|
||||
static Node *
|
||||
replace_correlation_vars_mutator(Node *node, void *context)
|
||||
{
|
||||
if (node == NULL)
|
||||
return NULL;
|
||||
if (IsA(node, Var))
|
||||
{
|
||||
if (((Var *) node)->varlevelsup > 0)
|
||||
return (Node *) replace_var((Var *) node);
|
||||
}
|
||||
return expression_tree_mutator(node,
|
||||
replace_correlation_vars_mutator,
|
||||
context);
|
||||
}
|
||||
|
||||
/* XXX should replace this with use of a generalized tree rebuilder,
|
||||
* designed along the same lines as expression_tree_walker.
|
||||
* Not done yet.
|
||||
/*
|
||||
* Expand SubLinks to SubPlans in the given expression.
|
||||
*/
|
||||
|
||||
static Node *process_sublinks_mutator(Node *node, void *context);
|
||||
|
||||
Node *
|
||||
SS_process_sublinks(Node *expr)
|
||||
{
|
||||
if (expr == NULL)
|
||||
/* No setup needed for tree walk, so away we go */
|
||||
return process_sublinks_mutator(expr, NULL);
|
||||
}
|
||||
|
||||
static Node *
|
||||
process_sublinks_mutator(Node *node, void *context)
|
||||
{
|
||||
if (node == NULL)
|
||||
return NULL;
|
||||
if (IsA(expr, SubLink))
|
||||
if (IsA(node, SubLink))
|
||||
{
|
||||
expr = _make_subplan((SubLink *) expr);
|
||||
}
|
||||
else if (single_node(expr))
|
||||
return expr;
|
||||
else if (IsA(expr, List))
|
||||
{
|
||||
List *le;
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
|
||||
foreach(le, (List *) expr)
|
||||
lfirst(le) = SS_process_sublinks((Node *) lfirst(le));
|
||||
}
|
||||
else if (IsA(expr, Expr))
|
||||
{
|
||||
/* We should never see a subplan node here, since this is the
|
||||
* routine that makes 'em in the first place. No need to check.
|
||||
/* First, scan the lefthand-side expressions.
|
||||
* This is a tad klugy since we modify the input SubLink node,
|
||||
* but that should be OK (make_subplan does it too!)
|
||||
*/
|
||||
((Expr *) expr)->args = (List *)
|
||||
SS_process_sublinks((Node *) ((Expr *) expr)->args);
|
||||
sublink->lefthand = (List *)
|
||||
process_sublinks_mutator((Node *) sublink->lefthand, context);
|
||||
/* Now build the SubPlan node and make the expr to return */
|
||||
return make_subplan(sublink);
|
||||
}
|
||||
else if (IsA(expr, Aggref))
|
||||
((Aggref *) expr)->target = SS_process_sublinks(((Aggref *) expr)->target);
|
||||
else if (IsA(expr, Iter))
|
||||
((Iter *) expr)->iterexpr = SS_process_sublinks(((Iter *) expr)->iterexpr);
|
||||
else if (IsA(expr, ArrayRef))
|
||||
{
|
||||
((ArrayRef *) expr)->refupperindexpr = (List *)
|
||||
SS_process_sublinks((Node *) ((ArrayRef *) expr)->refupperindexpr);
|
||||
((ArrayRef *) expr)->reflowerindexpr = (List *)
|
||||
SS_process_sublinks((Node *) ((ArrayRef *) expr)->reflowerindexpr);
|
||||
((ArrayRef *) expr)->refexpr = SS_process_sublinks(((ArrayRef *) expr)->refexpr);
|
||||
((ArrayRef *) expr)->refassgnexpr = SS_process_sublinks(((ArrayRef *) expr)->refassgnexpr);
|
||||
}
|
||||
else if (IsA(expr, CaseExpr))
|
||||
{
|
||||
CaseExpr *caseexpr = (CaseExpr *) expr;
|
||||
List *le;
|
||||
/*
|
||||
* Note that we will never see a SubPlan expression in the input
|
||||
* (since this is the very routine that creates 'em to begin with).
|
||||
* So the code in expression_tree_mutator() that might do
|
||||
* inappropriate things with SubPlans or SubLinks will not be
|
||||
* exercised.
|
||||
*/
|
||||
Assert(! is_subplan(node));
|
||||
|
||||
foreach(le, caseexpr->args)
|
||||
{
|
||||
CaseWhen *when = (CaseWhen *) lfirst(le);
|
||||
Assert(IsA(when, CaseWhen));
|
||||
when->expr = SS_process_sublinks(when->expr);
|
||||
when->result = SS_process_sublinks(when->result);
|
||||
}
|
||||
/* caseexpr->arg should be null, but we'll check it anyway */
|
||||
caseexpr->arg = SS_process_sublinks(caseexpr->arg);
|
||||
caseexpr->defresult = SS_process_sublinks(caseexpr->defresult);
|
||||
}
|
||||
else
|
||||
elog(ERROR, "SS_process_sublinks: can't handle node %d",
|
||||
nodeTag(expr));
|
||||
|
||||
return expr;
|
||||
return expression_tree_mutator(node,
|
||||
process_sublinks_mutator,
|
||||
context);
|
||||
}
|
||||
|
||||
List *
|
||||
@ -585,7 +575,9 @@ SS_finalize_plan(Plan *plan)
|
||||
return results.paramids;
|
||||
}
|
||||
|
||||
/* Construct a list of all subplans found within the given node tree */
|
||||
/*
|
||||
* Construct a list of all subplans found within the given node tree.
|
||||
*/
|
||||
|
||||
static bool SS_pull_subplan_walker(Node *node, List **listptr);
|
||||
|
||||
@ -606,8 +598,7 @@ SS_pull_subplan_walker(Node *node, List **listptr)
|
||||
if (is_subplan(node))
|
||||
{
|
||||
*listptr = lappend(*listptr, ((Expr *) node)->oper);
|
||||
/* XXX original code did not examine args to subplan, is this right? */
|
||||
return false;
|
||||
/* fall through to check args to subplan */
|
||||
}
|
||||
return expression_tree_walker(node, SS_pull_subplan_walker,
|
||||
(void *) listptr);
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.48 1999/08/22 20:14:53 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.49 1999/08/25 23:21:41 tgl Exp $
|
||||
*
|
||||
* HISTORY
|
||||
* AUTHOR DATE MAJOR EVENT
|
||||
@ -817,8 +817,8 @@ CommuteClause(Expr *clause)
|
||||
* the args and slink->oper lists (which belong to the outer plan), but it
|
||||
* will *not* visit the inner plan, since that's typically what expression
|
||||
* tree walkers want. A walker that wants to visit the subplan can force
|
||||
* appropriate behavior by recognizing subplan nodes and doing the right
|
||||
* thing.
|
||||
* appropriate behavior by recognizing subplan expression nodes and doing
|
||||
* the right thing.
|
||||
*
|
||||
* Bare SubLink nodes (without a SUBPLAN_EXPR) are handled by recursing into
|
||||
* the "lefthand" argument list only. (A bare SubLink should be seen only if
|
||||
@ -854,26 +854,18 @@ expression_tree_walker(Node *node, bool (*walker) (), void *context)
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
if (expr->opType == SUBPLAN_EXPR)
|
||||
{
|
||||
/* examine args list (params to be passed to subplan) */
|
||||
if (expression_tree_walker((Node *) expr->args,
|
||||
walker, context))
|
||||
return true;
|
||||
/* examine oper list as well */
|
||||
if (expression_tree_walker(
|
||||
(Node *) ((SubPlan *) expr->oper)->sublink->oper,
|
||||
walker, context))
|
||||
return true;
|
||||
/* but not the subplan itself */
|
||||
}
|
||||
else
|
||||
{
|
||||
/* for other Expr node types, just examine args list */
|
||||
if (expression_tree_walker((Node *) expr->args,
|
||||
walker, context))
|
||||
/* recurse to the SubLink node (skipping SubPlan!) */
|
||||
if (walker((Node *) ((SubPlan *) expr->oper)->sublink,
|
||||
context))
|
||||
return true;
|
||||
}
|
||||
/* for all Expr node types, examine args list */
|
||||
if (expression_tree_walker((Node *) expr->args,
|
||||
walker, context))
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case T_Aggref:
|
||||
@ -918,11 +910,20 @@ expression_tree_walker(Node *node, bool (*walker) (), void *context)
|
||||
}
|
||||
break;
|
||||
case T_SubLink:
|
||||
/* A "bare" SubLink (note we will not come here if we found
|
||||
* a SUBPLAN_EXPR node above it). Examine the lefthand side,
|
||||
* but not the oper list nor the subquery.
|
||||
*/
|
||||
return walker(((SubLink *) node)->lefthand, context);
|
||||
{
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
|
||||
/* If the SubLink has already been processed by subselect.c,
|
||||
* it will have lefthand=NIL, and we only need to look at
|
||||
* the oper list. Otherwise we only need to look at lefthand
|
||||
* (the Oper nodes in the oper list are deemed uninteresting).
|
||||
*/
|
||||
if (sublink->lefthand)
|
||||
return walker((Node *) sublink->lefthand, context);
|
||||
else
|
||||
return walker((Node *) sublink->oper, context);
|
||||
}
|
||||
break;
|
||||
case T_List:
|
||||
foreach(temp, (List *) node)
|
||||
{
|
||||
@ -988,8 +989,8 @@ expression_tree_walker(Node *node, bool (*walker) (), void *context)
|
||||
* the args and slink->oper 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 nodes and doing the
|
||||
* right thing.
|
||||
* can force appropriate behavior by recognizing subplan expression nodes
|
||||
* and doing the right thing.
|
||||
*
|
||||
* Bare SubLink nodes (without a SUBPLAN_EXPR) are handled by recursing into
|
||||
* the "lefthand" argument list only. (A bare SubLink should be seen only if
|
||||
|
||||
@ -7,12 +7,14 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.56 1999/08/05 02:33:53 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.57 1999/08/25 23:21:34 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "postgres.h"
|
||||
|
||||
#include "catalog/pg_operator.h"
|
||||
#include "nodes/makefuncs.h"
|
||||
#include "nodes/params.h"
|
||||
#include "nodes/relation.h"
|
||||
@ -22,6 +24,7 @@
|
||||
#include "parser/parse_coerce.h"
|
||||
#include "parser/parse_expr.h"
|
||||
#include "parser/parse_func.h"
|
||||
#include "parser/parse_oper.h"
|
||||
#include "parser/parse_relation.h"
|
||||
#include "parser/parse_target.h"
|
||||
#include "utils/builtins.h"
|
||||
@ -209,7 +212,15 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
elog(ERROR, "parser: bad query in subselect");
|
||||
sublink->subselect = (Node *) qtree;
|
||||
|
||||
if (sublink->subLinkType != EXISTS_SUBLINK)
|
||||
if (sublink->subLinkType == EXISTS_SUBLINK)
|
||||
{
|
||||
/* EXISTS needs no lefthand or combining operator.
|
||||
* These fields should be NIL already, but make sure.
|
||||
*/
|
||||
sublink->lefthand = NIL;
|
||||
sublink->oper = NIL;
|
||||
}
|
||||
else
|
||||
{
|
||||
char *op = lfirst(sublink->oper);
|
||||
List *left_list = sublink->lefthand;
|
||||
@ -236,27 +247,39 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
{
|
||||
TargetEntry *tent = (TargetEntry *) lfirst(right_list);
|
||||
Node *lexpr;
|
||||
Expr *op_expr;
|
||||
Operator optup;
|
||||
Form_pg_operator opform;
|
||||
Oper *newop;
|
||||
|
||||
if (! tent->resdom->resjunk)
|
||||
{
|
||||
if (left_list == NIL)
|
||||
elog(ERROR, "parser: Subselect has too many fields.");
|
||||
lexpr = lfirst(left_list);
|
||||
left_list = lnext(left_list);
|
||||
op_expr = make_op(op, lexpr, tent->expr);
|
||||
if (op_expr->typeOid != BOOLOID &&
|
||||
sublink->subLinkType != EXPR_SUBLINK)
|
||||
elog(ERROR, "parser: '%s' must return 'bool' to be used with quantified predicate subquery", op);
|
||||
sublink->oper = lappend(sublink->oper, op_expr);
|
||||
}
|
||||
right_list = lnext(right_list);
|
||||
if (tent->resdom->resjunk)
|
||||
continue;
|
||||
|
||||
if (left_list == NIL)
|
||||
elog(ERROR, "parser: Subselect has too many fields.");
|
||||
lexpr = lfirst(left_list);
|
||||
left_list = lnext(left_list);
|
||||
|
||||
optup = oper(op,
|
||||
exprType(lexpr),
|
||||
exprType(tent->expr),
|
||||
FALSE);
|
||||
opform = (Form_pg_operator) GETSTRUCT(optup);
|
||||
|
||||
if (opform->oprresult != BOOLOID &&
|
||||
sublink->subLinkType != EXPR_SUBLINK)
|
||||
elog(ERROR, "parser: '%s' must return 'bool' to be used with quantified predicate subquery", op);
|
||||
|
||||
newop = makeOper(oprid(optup),/* opno */
|
||||
InvalidOid, /* opid */
|
||||
opform->oprresult,
|
||||
0,
|
||||
NULL);
|
||||
sublink->oper = lappend(sublink->oper, newop);
|
||||
}
|
||||
if (left_list != NIL)
|
||||
elog(ERROR, "parser: Subselect has too few fields.");
|
||||
}
|
||||
else
|
||||
sublink->oper = NIL;
|
||||
result = (Node *) expr;
|
||||
break;
|
||||
}
|
||||
@ -565,10 +588,13 @@ exprType(Node *expr)
|
||||
|
||||
if (sublink->subLinkType == EXPR_SUBLINK)
|
||||
{
|
||||
/* return the result type of the combining operator */
|
||||
Expr *op_expr = (Expr *) lfirst(sublink->oper);
|
||||
/* return the result type of the combining operator;
|
||||
* should only be one...
|
||||
*/
|
||||
Oper *op = (Oper *) lfirst(sublink->oper);
|
||||
|
||||
type = op_expr->typeOid;
|
||||
Assert(IsA(op, Oper));
|
||||
type = op->opresulttype;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
@ -6,19 +6,23 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.54 1999/07/17 20:17:37 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.55 1999/08/25 23:21:43 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/heapam.h"
|
||||
#include "catalog/pg_operator.h"
|
||||
#include "catalog/pg_type.h"
|
||||
#include "miscadmin.h"
|
||||
#include "nodes/makefuncs.h"
|
||||
#include "optimizer/clauses.h"
|
||||
#include "optimizer/prep.h"
|
||||
#include "parser/analyze.h"
|
||||
#include "parser/parse_expr.h"
|
||||
#include "parser/parse_relation.h"
|
||||
#include "parser/parse_oper.h"
|
||||
#include "parser/parse_target.h"
|
||||
#include "parser/parse_type.h"
|
||||
#include "parser/parsetree.h"
|
||||
@ -642,9 +646,6 @@ modifyAggrefUplevel(Node *node)
|
||||
modifyAggrefUplevel(
|
||||
(Node *) (sub->lefthand));
|
||||
|
||||
modifyAggrefUplevel(
|
||||
(Node *) (sub->oper));
|
||||
|
||||
modifyAggrefUplevel(
|
||||
(Node *) (sub->subselect));
|
||||
}
|
||||
@ -816,12 +817,6 @@ modifyAggrefChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int subl
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
modifyAggrefChangeVarnodes(
|
||||
(Node **) (&(sub->oper)),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
modifyAggrefChangeVarnodes(
|
||||
(Node **) (&(sub->subselect)),
|
||||
rt_index,
|
||||
@ -989,6 +984,7 @@ modifyAggrefDropQual(Node **nodePtr, Node *orignode, Expr *expr)
|
||||
SubLink *sub = (SubLink *) node;
|
||||
SubLink *osub = (SubLink *) orignode;
|
||||
|
||||
/* what about the lefthand? */
|
||||
modifyAggrefDropQual(
|
||||
(Node **) (&(sub->subselect)),
|
||||
(Node *) (osub->subselect),
|
||||
@ -1046,19 +1042,21 @@ modifyAggrefMakeSublink(Expr *origexp, Query *parsetree)
|
||||
if (nodeTag(nth(1, exp->args)) == T_Aggref)
|
||||
elog(ERROR, "rewrite: comparision of 2 aggregate columns not supported");
|
||||
else
|
||||
elog(ERROR, "rewrite: aggregate column of view must be at rigth side in qual");
|
||||
elog(ERROR, "rewrite: aggregate column of view must be at right side in qual");
|
||||
}
|
||||
|
||||
aggref = (Aggref *) nth(1, exp->args);
|
||||
target = (Var *) (aggref->target);
|
||||
/* XXX bogus --- agg's target might not be a Var! */
|
||||
rte = (RangeTblEntry *) nth(target->varno - 1, parsetree->rtable);
|
||||
|
||||
tle = makeNode(TargetEntry);
|
||||
resdom = makeNode(Resdom);
|
||||
|
||||
aggref->usenulls = TRUE;
|
||||
aggref->usenulls = TRUE; /* XXX safe for all aggs?? */
|
||||
|
||||
resdom->resno = 1;
|
||||
resdom->restype = ((Oper *) (exp->oper))->opresulttype;
|
||||
resdom->restype = aggref->aggtype;
|
||||
resdom->restypmod = -1;
|
||||
resdom->resname = pstrdup("<noname>");
|
||||
resdom->reskey = 0;
|
||||
@ -1074,9 +1072,8 @@ modifyAggrefMakeSublink(Expr *origexp, Query *parsetree)
|
||||
sublink = makeNode(SubLink);
|
||||
sublink->subLinkType = EXPR_SUBLINK;
|
||||
sublink->useor = FALSE;
|
||||
sublink->lefthand = lappend(NIL, copyObject(lfirst(exp->args)));
|
||||
sublink->oper = lappend(NIL, copyObject(exp));
|
||||
sublink->subselect = NULL;
|
||||
sublink->lefthand = lcons(lfirst(exp->args), NIL);
|
||||
sublink->oper = lcons(exp->oper, NIL);
|
||||
|
||||
subquery = makeNode(Query);
|
||||
sublink->subselect = (Node *) subquery;
|
||||
@ -1105,8 +1102,6 @@ modifyAggrefMakeSublink(Expr *origexp, Query *parsetree)
|
||||
|
||||
modifyAggrefChangeVarnodes((Node **) &(sublink->lefthand), target->varno,
|
||||
1, target->varlevelsup);
|
||||
modifyAggrefChangeVarnodes((Node **) &(sublink->oper), target->varno,
|
||||
1, target->varlevelsup);
|
||||
modifyAggrefChangeVarnodes((Node **) &(sublink->subselect), target->varno,
|
||||
1, target->varlevelsup);
|
||||
|
||||
@ -1249,6 +1244,7 @@ modifyAggrefQual(Node **nodePtr, Query *parsetree)
|
||||
{
|
||||
SubLink *sub = (SubLink *) node;
|
||||
|
||||
/* lefthand ??? */
|
||||
modifyAggrefQual(
|
||||
(Node **) (&(sub->subselect)),
|
||||
(Query *) (sub->subselect));
|
||||
@ -1318,9 +1314,6 @@ checkQueryHasSubLink_walker(Node *node, void *context)
|
||||
return false;
|
||||
if (IsA(node, SubLink))
|
||||
return true; /* abort the tree traversal and return true */
|
||||
/* Note: we assume the tree has not yet been rewritten by subselect.c,
|
||||
* therefore we will find bare SubLink nodes and not SUBPLAN nodes.
|
||||
*/
|
||||
return expression_tree_walker(node, checkQueryHasSubLink_walker, context);
|
||||
}
|
||||
|
||||
@ -1654,8 +1647,6 @@ apply_RIR_view(Node **nodePtr, int rt_index, RangeTblEntry *rte, List *tlist, in
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sub = (SubLink *) node;
|
||||
List *tmp_lefthand,
|
||||
*tmp_oper;
|
||||
|
||||
apply_RIR_view(
|
||||
(Node **) (&(sub->lefthand)),
|
||||
@ -1672,14 +1663,6 @@ apply_RIR_view(Node **nodePtr, int rt_index, RangeTblEntry *rte, List *tlist, in
|
||||
tlist,
|
||||
modified,
|
||||
sublevels_up + 1);
|
||||
|
||||
tmp_lefthand = sub->lefthand;
|
||||
foreach(tmp_oper, sub->oper)
|
||||
{
|
||||
lfirst(((Expr *) lfirst(tmp_oper))->args) =
|
||||
lfirst(tmp_lefthand);
|
||||
tmp_lefthand = lnext(tmp_lefthand);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
@ -3014,31 +2997,47 @@ Except_Intersect_Rewrite(Query *parsetree)
|
||||
* of the targetlist must be (IN) or must not be (NOT IN) the
|
||||
* subselect
|
||||
*/
|
||||
n->lefthand = NIL;
|
||||
foreach(elist, intersect_node->targetList)
|
||||
{
|
||||
Node *expr = lfirst(elist);
|
||||
TargetEntry *tent = (TargetEntry *) expr;
|
||||
TargetEntry *tent = (TargetEntry *) lfirst(elist);
|
||||
|
||||
n->lefthand = lappend(n->lefthand, tent->expr);
|
||||
}
|
||||
|
||||
/*
|
||||
* The first arguments of oper also have to be created for the
|
||||
* sublink (they are the same as the lefthand side!)
|
||||
* Also prepare the list of Opers that must be used for the
|
||||
* comparisons (they depend on the specific datatypes involved!)
|
||||
*/
|
||||
left_expr = n->lefthand;
|
||||
right_expr = ((Query *) (n->subselect))->targetList;
|
||||
n->oper = NIL;
|
||||
|
||||
foreach(elist, left_expr)
|
||||
{
|
||||
Node *lexpr = lfirst(elist);
|
||||
Node *rexpr = lfirst(right_expr);
|
||||
TargetEntry *tent = (TargetEntry *) rexpr;
|
||||
Expr *op_expr;
|
||||
TargetEntry *tent = (TargetEntry *) lfirst(right_expr);
|
||||
Operator optup;
|
||||
Form_pg_operator opform;
|
||||
Oper *newop;
|
||||
|
||||
op_expr = make_op(op, lexpr, tent->expr);
|
||||
optup = oper(op,
|
||||
exprType(lexpr),
|
||||
exprType(tent->expr),
|
||||
FALSE);
|
||||
opform = (Form_pg_operator) GETSTRUCT(optup);
|
||||
|
||||
if (opform->oprresult != BOOLOID)
|
||||
elog(ERROR, "parser: '%s' must return 'bool' to be used with quantified predicate subquery", op);
|
||||
|
||||
newop = makeOper(oprid(optup),/* opno */
|
||||
InvalidOid, /* opid */
|
||||
opform->oprresult,
|
||||
0,
|
||||
NULL);
|
||||
|
||||
n->oper = lappend(n->oper, newop);
|
||||
|
||||
n->oper = lappend(n->oper, op_expr);
|
||||
right_expr = lnext(right_expr);
|
||||
}
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.39 1999/08/21 03:49:13 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.40 1999/08/25 23:21:43 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -137,13 +137,7 @@ OffsetVarNodes(Node *node, int offset, int sublevels_up)
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sub = (SubLink *) node;
|
||||
List *tmp_oper,
|
||||
*tmp_lefthand;
|
||||
|
||||
/*
|
||||
* We also have to adapt the variables used in
|
||||
* sub->lefthand and sub->oper
|
||||
*/
|
||||
OffsetVarNodes(
|
||||
(Node *) (sub->lefthand),
|
||||
offset,
|
||||
@ -153,20 +147,6 @@ OffsetVarNodes(Node *node, int offset, int sublevels_up)
|
||||
(Node *) (sub->subselect),
|
||||
offset,
|
||||
sublevels_up + 1);
|
||||
|
||||
/*
|
||||
* Make sure the first argument of sub->oper points to the
|
||||
* same var as sub->lefthand does otherwise we will run
|
||||
* into troubles using aggregates (aggno will not be set
|
||||
* correctly)
|
||||
*/
|
||||
tmp_lefthand = sub->lefthand;
|
||||
foreach(tmp_oper, sub->oper)
|
||||
{
|
||||
lfirst(((Expr *) lfirst(tmp_oper))->args) =
|
||||
lfirst(tmp_lefthand);
|
||||
tmp_lefthand = lnext(tmp_lefthand);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
@ -357,8 +337,6 @@ ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sub = (SubLink *) node;
|
||||
List *tmp_oper,
|
||||
*tmp_lefthand;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *) (sub->lefthand),
|
||||
@ -371,20 +349,6 @@ ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up + 1);
|
||||
|
||||
/*
|
||||
* Make sure the first argument of sub->oper points to the
|
||||
* same var as sub->lefthand does otherwise we will run
|
||||
* into troubles using aggregates (aggno will not be set
|
||||
* correctly)
|
||||
*/
|
||||
tmp_lefthand = sub->lefthand;
|
||||
foreach(tmp_oper, sub->oper)
|
||||
{
|
||||
lfirst(((Expr *) lfirst(tmp_oper))->args) =
|
||||
lfirst(tmp_lefthand);
|
||||
tmp_lefthand = lnext(tmp_lefthand);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
@ -732,6 +696,7 @@ ResolveNew(RewriteInfo *info, List *targetlist, Node **nodePtr,
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
Query *query = (Query *) sublink->subselect;
|
||||
|
||||
/* XXX what about lefthand? What about rest of subquery? */
|
||||
ResolveNew(info, targetlist, (Node **) &(query->qual), sublevels_up + 1);
|
||||
}
|
||||
break;
|
||||
@ -888,6 +853,7 @@ nodeHandleRIRAttributeRule(Node **nodePtr,
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
Query *query = (Query *) sublink->subselect;
|
||||
|
||||
/* XXX what about lefthand? What about rest of subquery? */
|
||||
nodeHandleRIRAttributeRule((Node **) &(query->qual), rtable, targetlist,
|
||||
rt_index, attr_num, modified, badsql,
|
||||
sublevels_up + 1);
|
||||
@ -1062,9 +1028,6 @@ nodeHandleViewRule(Node **nodePtr,
|
||||
{
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
Query *query = (Query *) sublink->subselect;
|
||||
List *tmp_lefthand,
|
||||
*tmp_oper;
|
||||
|
||||
|
||||
nodeHandleViewRule((Node **) &(query->qual), rtable, targetlist,
|
||||
rt_index, modified, sublevels_up + 1);
|
||||
@ -1078,30 +1041,10 @@ nodeHandleViewRule(Node **nodePtr,
|
||||
|
||||
/*
|
||||
* We also have to adapt the variables used in
|
||||
* sublink->lefthand and sublink->oper
|
||||
* sublink->lefthand
|
||||
*/
|
||||
nodeHandleViewRule((Node **) &(sublink->lefthand), rtable,
|
||||
targetlist, rt_index, modified, sublevels_up);
|
||||
|
||||
/*
|
||||
* Make sure the first argument of sublink->oper points to
|
||||
* the same var as sublink->lefthand does otherwise we
|
||||
* will run into troubles using aggregates (aggno will not
|
||||
* be set correctly
|
||||
*/
|
||||
pfree(lfirst(((Expr *) lfirst(sublink->oper))->args));
|
||||
lfirst(((Expr *) lfirst(sublink->oper))->args) =
|
||||
lfirst(sublink->lefthand);
|
||||
|
||||
|
||||
/* INTERSECT want's this - Jan */
|
||||
|
||||
/*
|
||||
* tmp_lefthand = sublink->lefthand; foreach(tmp_oper,
|
||||
* sublink->oper) { lfirst(((Expr *)
|
||||
* lfirst(tmp_oper))->args) = lfirst(tmp_lefthand);
|
||||
* tmp_lefthand = lnext(tmp_lefthand); }
|
||||
*/
|
||||
}
|
||||
break;
|
||||
default:
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
* out of it's tuple
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.22 1999/08/21 03:48:53 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.23 1999/08/25 23:21:35 tgl Exp $
|
||||
*
|
||||
* This software is copyrighted by Jan Wieck - Hamburg.
|
||||
*
|
||||
@ -1586,7 +1586,7 @@ get_sublink_expr(QryHier *qh, int rt_index, Node *node, bool varprefix)
|
||||
{
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
Query *query = (Query *) (sublink->subselect);
|
||||
Expr *expr;
|
||||
Oper *oper;
|
||||
List *l;
|
||||
char *sep;
|
||||
char buf[BUFSIZE];
|
||||
@ -1620,20 +1620,20 @@ get_sublink_expr(QryHier *qh, int rt_index, Node *node, bool varprefix)
|
||||
break;
|
||||
|
||||
case ANY_SUBLINK:
|
||||
expr = (Expr *) lfirst(sublink->oper);
|
||||
strcat(buf, get_opname(((Oper *) (expr->oper))->opno));
|
||||
oper = (Oper *) lfirst(sublink->oper);
|
||||
strcat(buf, get_opname(oper->opno));
|
||||
strcat(buf, " ANY ");
|
||||
break;
|
||||
|
||||
case ALL_SUBLINK:
|
||||
expr = (Expr *) lfirst(sublink->oper);
|
||||
strcat(buf, get_opname(((Oper *) (expr->oper))->opno));
|
||||
oper = (Oper *) lfirst(sublink->oper);
|
||||
strcat(buf, get_opname(oper->opno));
|
||||
strcat(buf, " ALL ");
|
||||
break;
|
||||
|
||||
case EXPR_SUBLINK:
|
||||
expr = (Expr *) lfirst(sublink->oper);
|
||||
strcat(buf, get_opname(((Oper *) (expr->oper))->opno));
|
||||
oper = (Oper *) lfirst(sublink->oper);
|
||||
strcat(buf, get_opname(oper->opno));
|
||||
strcat(buf, " ");
|
||||
break;
|
||||
|
||||
@ -1766,6 +1766,7 @@ check_if_rte_used(int rt_index, Node *node, int sup)
|
||||
|
||||
if (check_if_rte_used(rt_index, (Node *) (query->qual), sup + 1))
|
||||
return TRUE;
|
||||
/* why aren't we looking at query->targetlist, havingQual? */
|
||||
|
||||
if (check_if_rte_used(rt_index, (Node *) (sublink->lefthand), sup))
|
||||
return TRUE;
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: primnodes.h,v 1.35 1999/08/22 20:15:00 tgl Exp $
|
||||
* $Id: primnodes.h,v 1.36 1999/08/25 23:21:36 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -319,10 +319,36 @@ typedef struct Aggref
|
||||
/* ----------------
|
||||
* SubLink
|
||||
* subLinkType - EXISTS, ALL, ANY, EXPR
|
||||
* useor - TRUE for <>
|
||||
* lefthand - list of Var/Const nodes on the left
|
||||
* useor - TRUE for <> (combine op results with "or" not "and")
|
||||
* lefthand - list of outer-query expressions on the left
|
||||
* oper - list of Oper nodes
|
||||
* subselect - subselect as Query* or parsetree
|
||||
*
|
||||
* NOTE: lefthand and oper have varying meanings depending on where you look
|
||||
* in the parse/plan pipeline:
|
||||
* 1. gram.y delivers a list of the (untransformed) lefthand expressions in
|
||||
* lefthand, and sets oper to a one-element list containing the string
|
||||
* name of the operator.
|
||||
* 2. The parser's expression transformation transforms lefthand normally,
|
||||
* and replaces oper with a list of Oper 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 actual Expr trees for
|
||||
* these operators yet. This is the representation seen in saved rules
|
||||
* and in the rewriter.
|
||||
* 3. Finally, the planner converts the oper list to a list of normal Expr
|
||||
* nodes representing the application of the operator(s) to the lefthand
|
||||
* expressions and values from the inner targetlist. The inner
|
||||
* targetlist items are represented by placeholder Param or Const nodes.
|
||||
* The lefthand field is set to NIL, since its expressions are now in
|
||||
* the Expr list. This representation is passed to the executor.
|
||||
*
|
||||
* Planner routines that might see either representation 2 or 3 can tell
|
||||
* the difference by checking whether lefthand is NIL or not. Also,
|
||||
* representation 2 appears in a "bare" SubLink, while representation 3 is
|
||||
* found in SubLinks that are children of SubPlan nodes.
|
||||
*
|
||||
* In an EXISTS SubLink, both lefthand and oper are unused and are always NIL.
|
||||
* ----------------
|
||||
*/
|
||||
typedef enum SubLinkType
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user