mirror of
https://github.com/postgres/postgres.git
synced 2025-07-28 23:42:10 +03:00
The patch does 2 things:
Fixes a bug in the rule system that caused a crashing
backend when a join-view with calculated column is used
in subselect.
Modifies EXPLAIN to explain rewritten queries instead of
the plain SeqScan on a view. Rules can produce very deep
MORE
Jan.
This commit is contained in:
Bruce Momjian
@ -6,7 +6,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.24 1998/10/20 17:21:43 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.25 1998/10/21 16:21:24 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -48,8 +48,6 @@ static RewriteInfo *gatherRewriteMeta(Query *parsetree,
|
||||
bool *instead_flag);
|
||||
static bool rangeTableEntry_used(Node *node, int rt_index, int sublevels_up);
|
||||
static bool attribute_used(Node *node, int rt_index, int attno, int sublevels_up);
|
||||
static void offset_varnodes(Node *node, int offset, int sublevels_up);
|
||||
static void change_varnodes(Node *node, int rt_index, int new_index, int sublevels_up);
|
||||
static void modifyAggregUplevel(Node *node);
|
||||
static void modifyAggregChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up);
|
||||
static void modifyAggregDropQual(Node **nodePtr, Node *orignode, Expr *expr);
|
||||
@ -107,9 +105,9 @@ gatherRewriteMeta(Query *parsetree,
|
||||
info->rt = append(info->rt, info->rule_action->rtable);
|
||||
|
||||
info->new_varno = PRS2_NEW_VARNO + rt_length;
|
||||
OffsetVarNodes(info->rule_action->qual, rt_length);
|
||||
OffsetVarNodes((Node *) info->rule_action->targetList, rt_length);
|
||||
OffsetVarNodes(info->rule_qual, rt_length);
|
||||
OffsetVarNodes(info->rule_action->qual, rt_length, 0);
|
||||
OffsetVarNodes((Node *) info->rule_action->targetList, rt_length, 0);
|
||||
OffsetVarNodes(info->rule_qual, rt_length, 0);
|
||||
ChangeVarNodes((Node *) info->rule_action->qual,
|
||||
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
||||
ChangeVarNodes((Node *) info->rule_action->targetList,
|
||||
@ -550,364 +548,6 @@ attribute_used(Node *node, int rt_index, int attno, int sublevels_up)
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* offset_varnodes -
|
||||
* We need another version of OffsetVarNodes() when processing
|
||||
* RIR rules
|
||||
*/
|
||||
static void
|
||||
offset_varnodes(Node *node, int offset, int sublevels_up)
|
||||
{
|
||||
if (node == NULL)
|
||||
return;
|
||||
|
||||
switch(nodeTag(node)) {
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(tle->expr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Aggreg:
|
||||
{
|
||||
Aggreg *agg = (Aggreg *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(agg->target),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_GroupClause:
|
||||
{
|
||||
GroupClause *grp = (GroupClause *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(grp->entry),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *exp = (Expr *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(exp->args),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Iter:
|
||||
{
|
||||
Iter *iter = (Iter *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(iter->iterexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_ArrayRef:
|
||||
{
|
||||
ArrayRef *ref = (ArrayRef *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(ref->refupperindexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
offset_varnodes(
|
||||
(Node *)(ref->reflowerindexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
offset_varnodes(
|
||||
(Node *)(ref->refexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
offset_varnodes(
|
||||
(Node *)(ref->refassgnexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *)node;
|
||||
|
||||
if (var->varlevelsup == sublevels_up) {
|
||||
var->varno += offset;
|
||||
var->varnoold += offset;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Param:
|
||||
break;
|
||||
|
||||
case T_Const:
|
||||
break;
|
||||
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach (l, (List *)node)
|
||||
offset_varnodes(
|
||||
(Node *)lfirst(l),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sub = (SubLink *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(sub->lefthand),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(sub->subselect),
|
||||
offset,
|
||||
sublevels_up + 1);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Query:
|
||||
{
|
||||
Query *qry = (Query *)node;
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(qry->targetList),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(qry->qual),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(qry->havingQual),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
offset_varnodes(
|
||||
(Node *)(qry->groupClause),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
elog(NOTICE, "unknown node tag %d in offset_varnodes()", nodeTag(node));
|
||||
elog(NOTICE, "Node is: %s", nodeToString(node));
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* change_varnodes -
|
||||
* and another ChangeVarNodes() too
|
||||
*/
|
||||
static void
|
||||
change_varnodes(Node *node, int rt_index, int new_index, int sublevels_up)
|
||||
{
|
||||
if (node == NULL)
|
||||
return;
|
||||
|
||||
switch(nodeTag(node)) {
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(tle->expr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Aggreg:
|
||||
{
|
||||
Aggreg *agg = (Aggreg *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(agg->target),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_GroupClause:
|
||||
{
|
||||
GroupClause *grp = (GroupClause *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(grp->entry),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *exp = (Expr *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(exp->args),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Iter:
|
||||
{
|
||||
Iter *iter = (Iter *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(iter->iterexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_ArrayRef:
|
||||
{
|
||||
ArrayRef *ref = (ArrayRef *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(ref->refupperindexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
change_varnodes(
|
||||
(Node *)(ref->reflowerindexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
change_varnodes(
|
||||
(Node *)(ref->refexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
change_varnodes(
|
||||
(Node *)(ref->refassgnexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *)node;
|
||||
|
||||
if (var->varlevelsup == sublevels_up &&
|
||||
var->varno == rt_index) {
|
||||
var->varno = new_index;
|
||||
var->varnoold = new_index;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Param:
|
||||
break;
|
||||
|
||||
case T_Const:
|
||||
break;
|
||||
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach (l, (List *)node)
|
||||
change_varnodes(
|
||||
(Node *)lfirst(l),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sub = (SubLink *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(sub->lefthand),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(sub->subselect),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up + 1);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Query:
|
||||
{
|
||||
Query *qry = (Query *)node;
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(qry->targetList),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(qry->qual),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(qry->havingQual),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
change_varnodes(
|
||||
(Node *)(qry->groupClause),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
elog(NOTICE, "unknown node tag %d in change_varnodes()", nodeTag(node));
|
||||
elog(NOTICE, "Node is: %s", nodeToString(node));
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* modifyAggregUplevel -
|
||||
* In the newly created sublink for an aggregate column used in
|
||||
@ -1655,6 +1295,121 @@ make_null(Oid type)
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
apply_RIR_adjust_sublevel(Node *node, int sublevels_up)
|
||||
{
|
||||
if (node == NULL)
|
||||
return;
|
||||
|
||||
switch(nodeTag(node)) {
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *)node;
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(tle->expr),
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Aggreg:
|
||||
{
|
||||
Aggreg *agg = (Aggreg *)node;
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(agg->target),
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_GroupClause:
|
||||
{
|
||||
GroupClause *grp = (GroupClause *)node;
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(grp->entry),
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *exp = (Expr *)node;
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(exp->args),
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Iter:
|
||||
{
|
||||
Iter *iter = (Iter *)node;
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(iter->iterexpr),
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_ArrayRef:
|
||||
{
|
||||
ArrayRef *ref = (ArrayRef *)node;
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(ref->refupperindexpr),
|
||||
sublevels_up);
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(ref->reflowerindexpr),
|
||||
sublevels_up);
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(ref->refexpr),
|
||||
sublevels_up);
|
||||
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)(ref->refassgnexpr),
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *)node;
|
||||
|
||||
var->varlevelsup = sublevels_up;
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Param:
|
||||
break;
|
||||
|
||||
case T_Const:
|
||||
break;
|
||||
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach (l, (List *)node) {
|
||||
apply_RIR_adjust_sublevel(
|
||||
(Node *)lfirst(l),
|
||||
sublevels_up);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
elog(NOTICE, "unknown node tag %d in attribute_used()", nodeTag(node));
|
||||
elog(NOTICE, "Node is: %s", nodeToString(node));
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
apply_RIR_view(Node **nodePtr, int rt_index, RangeTblEntry *rte, List *tlist, int *modified, int sublevels_up)
|
||||
{
|
||||
@ -1790,10 +1545,8 @@ apply_RIR_view(Node **nodePtr, int rt_index, RangeTblEntry *rte, List *tlist, in
|
||||
}
|
||||
|
||||
exp = copyObject(exp);
|
||||
if (var->varlevelsup > 0 &&
|
||||
nodeTag(exp) == T_Var) {
|
||||
((Var *)exp)->varlevelsup = var->varlevelsup;
|
||||
}
|
||||
if (var->varlevelsup > 0)
|
||||
apply_RIR_adjust_sublevel(exp, var->varlevelsup);
|
||||
*nodePtr = exp;
|
||||
*modified = TRUE;
|
||||
}
|
||||
@ -1885,8 +1638,6 @@ apply_RIR_view(Node **nodePtr, int rt_index, RangeTblEntry *rte, List *tlist, in
|
||||
elog(NOTICE, "unknown node tag %d in apply_RIR_view()", nodeTag(node));
|
||||
elog(NOTICE, "Node is: %s", nodeToString(node));
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -1938,12 +1689,12 @@ ApplyRetrieveRule(Query *parsetree,
|
||||
parsetree->rtable = rtable;
|
||||
|
||||
rule_action->rtable = rtable;
|
||||
offset_varnodes((Node *) rule_qual, rt_length, 0);
|
||||
offset_varnodes((Node *) rule_action, rt_length, 0);
|
||||
OffsetVarNodes((Node *) rule_qual, rt_length, 0);
|
||||
OffsetVarNodes((Node *) rule_action, rt_length, 0);
|
||||
|
||||
change_varnodes((Node *) rule_qual,
|
||||
ChangeVarNodes((Node *) rule_qual,
|
||||
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
||||
change_varnodes((Node *) rule_action,
|
||||
ChangeVarNodes((Node *) rule_action,
|
||||
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
||||
|
||||
if (relation_level)
|
||||
@ -2246,7 +1997,7 @@ CopyAndAddQual(Query *parsetree,
|
||||
rt_length = length(rtable);
|
||||
rtable = append(rtable, listCopy(rule_action->rtable));
|
||||
new_tree->rtable = rtable;
|
||||
OffsetVarNodes(new_qual, rt_length);
|
||||
OffsetVarNodes(new_qual, rt_length, 0);
|
||||
ChangeVarNodes(new_qual, PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
||||
}
|
||||
/* XXX -- where current doesn't work for instead nothing.... yet */
|
||||
@ -2385,6 +2136,28 @@ fireRules(Query *parsetree,
|
||||
if (rule_action->commandType == CMD_NOTHING)
|
||||
continue;
|
||||
|
||||
/*--------------------------------------------------
|
||||
* We copy the qualifications of the parsetree
|
||||
* to the action and vice versa. So force
|
||||
* hasSubLinks if one of them has it.
|
||||
*
|
||||
* As of 6.4 only parsetree qualifications can
|
||||
* have sublinks. If this changes, we must make
|
||||
* this a node lookup at the end of rewriting.
|
||||
*
|
||||
* Jan
|
||||
*--------------------------------------------------
|
||||
*/
|
||||
if (parsetree->hasSubLinks && !rule_action->hasSubLinks)
|
||||
{
|
||||
rule_action = copyObject(rule_action);
|
||||
rule_action->hasSubLinks = TRUE;
|
||||
}
|
||||
if (!parsetree->hasSubLinks && rule_action->hasSubLinks)
|
||||
{
|
||||
parsetree->hasSubLinks = TRUE;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------
|
||||
* Step 1:
|
||||
* Rewrite current.attribute or current to tuple variable
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.21 1998/10/20 17:21:44 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.22 1998/10/21 16:21:26 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -32,222 +32,362 @@ static void ResolveNew(RewriteInfo *info, List *targetlist,
|
||||
Node **node, int sublevels_up);
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* OffsetVarnodes -
|
||||
*/
|
||||
void
|
||||
OffsetVarNodes(Node *node, int offset)
|
||||
OffsetVarNodes(Node *node, int offset, int sublevels_up)
|
||||
{
|
||||
if (node == NULL)
|
||||
return;
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
|
||||
switch(nodeTag(node)) {
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
TargetEntry *tle = (TargetEntry *)node;
|
||||
|
||||
OffsetVarNodes(tle->expr, offset);
|
||||
OffsetVarNodes(
|
||||
(Node *)(tle->expr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Aggreg:
|
||||
{
|
||||
Aggreg *agg = (Aggreg *) node;
|
||||
Aggreg *agg = (Aggreg *)node;
|
||||
|
||||
OffsetVarNodes(agg->target, offset);
|
||||
OffsetVarNodes(
|
||||
(Node *)(agg->target),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
/*
|
||||
* This has to be done to make queries using groupclauses work
|
||||
* on views
|
||||
*/
|
||||
case T_GroupClause:
|
||||
{
|
||||
GroupClause *group = (GroupClause *) node;
|
||||
GroupClause *grp = (GroupClause *)node;
|
||||
|
||||
OffsetVarNodes((Node *) (group->entry), offset);
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
OffsetVarNodes((Node *) expr->args, offset);
|
||||
}
|
||||
break;
|
||||
case T_Iter:
|
||||
{
|
||||
Iter *iter = (Iter *) node;
|
||||
|
||||
OffsetVarNodes((Node *) iter->iterexpr, offset);
|
||||
}
|
||||
break;
|
||||
case T_ArrayRef:
|
||||
{
|
||||
ArrayRef *ref = (ArrayRef *) node;
|
||||
|
||||
OffsetVarNodes((Node *) ref->refupperindexpr, offset);
|
||||
OffsetVarNodes((Node *) ref->reflowerindexpr, offset);
|
||||
OffsetVarNodes((Node *) ref->refexpr, offset);
|
||||
OffsetVarNodes((Node *) ref->refassgnexpr, offset);
|
||||
}
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *) node;
|
||||
|
||||
var->varno += offset;
|
||||
var->varnoold += offset;
|
||||
}
|
||||
break;
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
OffsetVarNodes(lfirst(l), offset);
|
||||
}
|
||||
break;
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
|
||||
/*
|
||||
* We also have to adapt the variables used in
|
||||
* sublink->lefthand and sublink->oper
|
||||
*/
|
||||
OffsetVarNodes((Node *) (sublink->lefthand), offset);
|
||||
|
||||
/*
|
||||
* 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)
|
||||
*/
|
||||
lfirst(((Expr *) lfirst(sublink->oper))->args) =
|
||||
lfirst(sublink->lefthand);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ChangeVarNodes(Node *node, int old_varno, int new_varno, int sublevels_up)
|
||||
{
|
||||
if (node == NULL)
|
||||
return;
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
ChangeVarNodes(tle->expr, old_varno, new_varno, sublevels_up);
|
||||
}
|
||||
break;
|
||||
case T_Aggreg:
|
||||
{
|
||||
Aggreg *agg = (Aggreg *) node;
|
||||
|
||||
ChangeVarNodes(agg->target, old_varno, new_varno, sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
/*
|
||||
* This has to be done to make queries using groupclauses work
|
||||
* on views
|
||||
*/
|
||||
case T_GroupClause:
|
||||
{
|
||||
GroupClause *group = (GroupClause *) node;
|
||||
|
||||
ChangeVarNodes((Node *) (group->entry), old_varno, new_varno,
|
||||
sublevels_up);
|
||||
OffsetVarNodes(
|
||||
(Node *)(grp->entry),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
Expr *exp = (Expr *)node;
|
||||
|
||||
ChangeVarNodes((Node *) expr->args, old_varno, new_varno, sublevels_up);
|
||||
OffsetVarNodes(
|
||||
(Node *)(exp->args),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Iter:
|
||||
{
|
||||
Iter *iter = (Iter *) node;
|
||||
Iter *iter = (Iter *)node;
|
||||
|
||||
ChangeVarNodes((Node *) iter->iterexpr, old_varno, new_varno, sublevels_up);
|
||||
OffsetVarNodes(
|
||||
(Node *)(iter->iterexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_ArrayRef:
|
||||
{
|
||||
ArrayRef *ref = (ArrayRef *) node;
|
||||
ArrayRef *ref = (ArrayRef *)node;
|
||||
|
||||
ChangeVarNodes((Node *) ref->refupperindexpr, old_varno, new_varno, sublevels_up);
|
||||
ChangeVarNodes((Node *) ref->reflowerindexpr, old_varno, new_varno, sublevels_up);
|
||||
ChangeVarNodes((Node *) ref->refexpr, old_varno, new_varno, sublevels_up);
|
||||
ChangeVarNodes((Node *) ref->refassgnexpr, old_varno, new_varno, sublevels_up);
|
||||
OffsetVarNodes(
|
||||
(Node *)(ref->refupperindexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
OffsetVarNodes(
|
||||
(Node *)(ref->reflowerindexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
OffsetVarNodes(
|
||||
(Node *)(ref->refexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
OffsetVarNodes(
|
||||
(Node *)(ref->refassgnexpr),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *) node;
|
||||
Var *var = (Var *)node;
|
||||
|
||||
if (var->varno == old_varno &&
|
||||
var->varlevelsup == sublevels_up)
|
||||
{
|
||||
var->varno = new_varno;
|
||||
var->varnoold = new_varno;
|
||||
if (var->varlevelsup == sublevels_up) {
|
||||
var->varno += offset;
|
||||
var->varnoold += offset;
|
||||
}
|
||||
if (var->varlevelsup > 0)
|
||||
OffsetVarNodes((Node *) var, 3);
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Param:
|
||||
break;
|
||||
|
||||
case T_Const:
|
||||
break;
|
||||
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
ChangeVarNodes(lfirst(l), old_varno, new_varno, sublevels_up);
|
||||
foreach (l, (List *)node)
|
||||
OffsetVarNodes(
|
||||
(Node *)lfirst(l),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sublink = (SubLink *) node;
|
||||
Query *query = (Query *) sublink->subselect;
|
||||
SubLink *sub = (SubLink *)node;
|
||||
|
||||
ChangeVarNodes((Node *) query->qual, old_varno, new_varno,
|
||||
sublevels_up + 1);
|
||||
OffsetVarNodes(
|
||||
(Node *)(sub->lefthand),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
/*
|
||||
* We also have to adapt the variables used in
|
||||
* sublink->lefthand and sublink->oper
|
||||
*/
|
||||
ChangeVarNodes((Node *) (sublink->lefthand), old_varno, new_varno,
|
||||
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
|
||||
*/
|
||||
|
||||
/*
|
||||
* lfirst(((Expr *) lfirst(sublink->oper))->args) =
|
||||
* lfirst(sublink->lefthand);
|
||||
*/
|
||||
OffsetVarNodes(
|
||||
(Node *)(sub->subselect),
|
||||
offset,
|
||||
sublevels_up + 1);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* ignore the others */
|
||||
|
||||
case T_Query:
|
||||
{
|
||||
Query *qry = (Query *)node;
|
||||
|
||||
OffsetVarNodes(
|
||||
(Node *)(qry->targetList),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
OffsetVarNodes(
|
||||
(Node *)(qry->qual),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
OffsetVarNodes(
|
||||
(Node *)(qry->havingQual),
|
||||
offset,
|
||||
sublevels_up);
|
||||
|
||||
OffsetVarNodes(
|
||||
(Node *)(qry->groupClause),
|
||||
offset,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
elog(NOTICE, "unknown node tag %d in OffsetVarNodes()", nodeTag(node));
|
||||
elog(NOTICE, "Node is: %s", nodeToString(node));
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* ChangeVarNodes -
|
||||
*/
|
||||
void
|
||||
ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
|
||||
{
|
||||
if (node == NULL)
|
||||
return;
|
||||
|
||||
switch(nodeTag(node)) {
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(tle->expr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Aggreg:
|
||||
{
|
||||
Aggreg *agg = (Aggreg *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(agg->target),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_GroupClause:
|
||||
{
|
||||
GroupClause *grp = (GroupClause *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(grp->entry),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *exp = (Expr *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(exp->args),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Iter:
|
||||
{
|
||||
Iter *iter = (Iter *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(iter->iterexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_ArrayRef:
|
||||
{
|
||||
ArrayRef *ref = (ArrayRef *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(ref->refupperindexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
ChangeVarNodes(
|
||||
(Node *)(ref->reflowerindexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
ChangeVarNodes(
|
||||
(Node *)(ref->refexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
ChangeVarNodes(
|
||||
(Node *)(ref->refassgnexpr),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *)node;
|
||||
|
||||
if (var->varlevelsup == sublevels_up &&
|
||||
var->varno == rt_index) {
|
||||
var->varno = new_index;
|
||||
var->varnoold = new_index;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Param:
|
||||
break;
|
||||
|
||||
case T_Const:
|
||||
break;
|
||||
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach (l, (List *)node)
|
||||
ChangeVarNodes(
|
||||
(Node *)lfirst(l),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sub = (SubLink *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(sub->lefthand),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(sub->subselect),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up + 1);
|
||||
}
|
||||
break;
|
||||
|
||||
case T_Query:
|
||||
{
|
||||
Query *qry = (Query *)node;
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(qry->targetList),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(qry->qual),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(qry->havingQual),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
|
||||
ChangeVarNodes(
|
||||
(Node *)(qry->groupClause),
|
||||
rt_index,
|
||||
new_index,
|
||||
sublevels_up);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
elog(NOTICE, "unknown node tag %d in ChangeVarNodes()", nodeTag(node));
|
||||
elog(NOTICE, "Node is: %s", nodeToString(node));
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
AddQual(Query *parsetree, Node *qual)
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user