05e3d0ee86
SQL92 semantics, including support for ALL option. All three can be used in subqueries and views. DISTINCT and ORDER BY work now in views, too. This rewrite fixes many problems with cross-datatype UNIONs and INSERT/SELECT where the SELECT yields different datatypes than the INSERT needs. I did that by making UNION subqueries and SELECT in INSERT be treated like subselects-in-FROM, thereby allowing an extra level of targetlist where the datatype conversions can be inserted safely. INITDB NEEDED!
889 lines
22 KiB
C
889 lines
22 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* rewriteManip.c
|
|
*
|
|
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.50 2000/10/05 19:11:34 tgl Exp $
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#include "postgres.h"
|
|
|
|
#include "optimizer/clauses.h"
|
|
#include "optimizer/tlist.h"
|
|
#include "parser/parsetree.h"
|
|
#include "parser/parse_clause.h"
|
|
#include "rewrite/rewriteManip.h"
|
|
#include "utils/lsyscache.h"
|
|
|
|
|
|
/* macros borrowed from expression_tree_mutator */
|
|
|
|
#define FLATCOPY(newnode, node, nodetype) \
|
|
( (newnode) = makeNode(nodetype), \
|
|
memcpy((newnode), (node), sizeof(nodetype)) )
|
|
|
|
#define MUTATE(newfield, oldfield, fieldtype, mutator, context) \
|
|
( (newfield) = (fieldtype) mutator((Node *) (oldfield), (context)) )
|
|
|
|
static bool checkExprHasAggs_walker(Node *node, void *context);
|
|
static bool checkExprHasSubLink_walker(Node *node, void *context);
|
|
|
|
|
|
/*
|
|
* checkExprHasAggs -
|
|
* Queries marked hasAggs might not have them any longer after
|
|
* rewriting. Check it.
|
|
*/
|
|
bool
|
|
checkExprHasAggs(Node *node)
|
|
{
|
|
/*
|
|
* If a Query is passed, examine it --- but we will not recurse
|
|
* into sub-Queries.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
return query_tree_walker((Query *) node, checkExprHasAggs_walker,
|
|
NULL, false);
|
|
else
|
|
return checkExprHasAggs_walker(node, NULL);
|
|
}
|
|
|
|
static bool
|
|
checkExprHasAggs_walker(Node *node, void *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, Aggref))
|
|
return true; /* abort the tree traversal and return
|
|
* true */
|
|
return expression_tree_walker(node, checkExprHasAggs_walker, context);
|
|
}
|
|
|
|
/*
|
|
* checkExprHasSubLink -
|
|
* Queries marked hasSubLinks might not have them any longer after
|
|
* rewriting. Check it.
|
|
*/
|
|
bool
|
|
checkExprHasSubLink(Node *node)
|
|
{
|
|
/*
|
|
* If a Query is passed, examine it --- but we will not recurse
|
|
* into sub-Queries.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
return query_tree_walker((Query *) node, checkExprHasSubLink_walker,
|
|
NULL, false);
|
|
else
|
|
return checkExprHasSubLink_walker(node, NULL);
|
|
}
|
|
|
|
static bool
|
|
checkExprHasSubLink_walker(Node *node, void *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, SubLink))
|
|
return true; /* abort the tree traversal and return
|
|
* true */
|
|
return expression_tree_walker(node, checkExprHasSubLink_walker, context);
|
|
}
|
|
|
|
|
|
/*
|
|
* OffsetVarNodes - adjust Vars when appending one query's RT to another
|
|
*
|
|
* Find all Var nodes in the given tree with varlevelsup == sublevels_up,
|
|
* and increment their varno fields (rangetable indexes) by 'offset'.
|
|
* The varnoold fields are adjusted similarly. Also, RangeTblRef nodes
|
|
* in join trees and setOp trees are adjusted.
|
|
*
|
|
* NOTE: although this has the form of a walker, we cheat and modify the
|
|
* nodes in-place. The given expression tree should have been copied
|
|
* earlier to ensure that no unwanted side-effects occur!
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
int offset;
|
|
int sublevels_up;
|
|
} OffsetVarNodes_context;
|
|
|
|
static bool
|
|
OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
|
|
if (var->varlevelsup == context->sublevels_up)
|
|
{
|
|
var->varno += context->offset;
|
|
var->varnoold += context->offset;
|
|
}
|
|
return false;
|
|
}
|
|
if (IsA(node, RangeTblRef))
|
|
{
|
|
RangeTblRef *rtr = (RangeTblRef *) node;
|
|
|
|
if (context->sublevels_up == 0)
|
|
rtr->rtindex += context->offset;
|
|
/* the subquery itself is visited separately */
|
|
return false;
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
/* Recurse into subselects */
|
|
bool result;
|
|
|
|
context->sublevels_up++;
|
|
result = query_tree_walker((Query *) node, OffsetVarNodes_walker,
|
|
(void *) context, true);
|
|
context->sublevels_up--;
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, OffsetVarNodes_walker,
|
|
(void *) context);
|
|
}
|
|
|
|
void
|
|
OffsetVarNodes(Node *node, int offset, int sublevels_up)
|
|
{
|
|
OffsetVarNodes_context context;
|
|
|
|
context.offset = offset;
|
|
context.sublevels_up = sublevels_up;
|
|
|
|
/*
|
|
* Must be prepared to start with a Query or a bare expression tree;
|
|
* if it's a Query, go straight to query_tree_walker to make sure that
|
|
* sublevels_up doesn't get incremented prematurely.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
query_tree_walker((Query *) node, OffsetVarNodes_walker,
|
|
(void *) &context, true);
|
|
else
|
|
OffsetVarNodes_walker(node, &context);
|
|
}
|
|
|
|
/*
|
|
* ChangeVarNodes - adjust Var nodes for a specific change of RT index
|
|
*
|
|
* Find all Var nodes in the given tree belonging to a specific relation
|
|
* (identified by sublevels_up and rt_index), and change their varno fields
|
|
* to 'new_index'. The varnoold fields are changed too. Also, RangeTblRef
|
|
* nodes in join trees and setOp trees are adjusted.
|
|
*
|
|
* NOTE: although this has the form of a walker, we cheat and modify the
|
|
* nodes in-place. The given expression tree should have been copied
|
|
* earlier to ensure that no unwanted side-effects occur!
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
int rt_index;
|
|
int new_index;
|
|
int sublevels_up;
|
|
} ChangeVarNodes_context;
|
|
|
|
static bool
|
|
ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
|
|
if (var->varlevelsup == context->sublevels_up &&
|
|
var->varno == context->rt_index)
|
|
{
|
|
var->varno = context->new_index;
|
|
var->varnoold = context->new_index;
|
|
}
|
|
return false;
|
|
}
|
|
if (IsA(node, RangeTblRef))
|
|
{
|
|
RangeTblRef *rtr = (RangeTblRef *) node;
|
|
|
|
if (context->sublevels_up == 0 &&
|
|
rtr->rtindex == context->rt_index)
|
|
rtr->rtindex = context->new_index;
|
|
/* the subquery itself is visited separately */
|
|
return false;
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
/* Recurse into subselects */
|
|
bool result;
|
|
|
|
context->sublevels_up++;
|
|
result = query_tree_walker((Query *) node, ChangeVarNodes_walker,
|
|
(void *) context, true);
|
|
context->sublevels_up--;
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, ChangeVarNodes_walker,
|
|
(void *) context);
|
|
}
|
|
|
|
void
|
|
ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
|
|
{
|
|
ChangeVarNodes_context context;
|
|
|
|
context.rt_index = rt_index;
|
|
context.new_index = new_index;
|
|
context.sublevels_up = sublevels_up;
|
|
|
|
/*
|
|
* Must be prepared to start with a Query or a bare expression tree;
|
|
* if it's a Query, go straight to query_tree_walker to make sure that
|
|
* sublevels_up doesn't get incremented prematurely.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
query_tree_walker((Query *) node, ChangeVarNodes_walker,
|
|
(void *) &context, true);
|
|
else
|
|
ChangeVarNodes_walker(node, &context);
|
|
}
|
|
|
|
/*
|
|
* IncrementVarSublevelsUp - adjust Var nodes when pushing them down in tree
|
|
*
|
|
* Find all Var nodes in the given tree having varlevelsup >= min_sublevels_up,
|
|
* and add delta_sublevels_up to their varlevelsup value. This is needed when
|
|
* an expression that's correct for some nesting level is inserted into a
|
|
* subquery. Ordinarily the initial call has min_sublevels_up == 0 so that
|
|
* all Vars are affected. The point of min_sublevels_up is that we can
|
|
* increment it when we recurse into a sublink, so that local variables in
|
|
* that sublink are not affected, only outer references to vars that belong
|
|
* to the expression's original query level or parents thereof.
|
|
*
|
|
* NOTE: although this has the form of a walker, we cheat and modify the
|
|
* Var nodes in-place. The given expression tree should have been copied
|
|
* earlier to ensure that no unwanted side-effects occur!
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
int delta_sublevels_up;
|
|
int min_sublevels_up;
|
|
} IncrementVarSublevelsUp_context;
|
|
|
|
static bool
|
|
IncrementVarSublevelsUp_walker(Node *node,
|
|
IncrementVarSublevelsUp_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
|
|
if (var->varlevelsup >= context->min_sublevels_up)
|
|
var->varlevelsup += context->delta_sublevels_up;
|
|
return false;
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
/* Recurse into subselects */
|
|
bool result;
|
|
|
|
context->min_sublevels_up++;
|
|
result = query_tree_walker((Query *) node,
|
|
IncrementVarSublevelsUp_walker,
|
|
(void *) context, true);
|
|
context->min_sublevels_up--;
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, IncrementVarSublevelsUp_walker,
|
|
(void *) context);
|
|
}
|
|
|
|
void
|
|
IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
|
|
int min_sublevels_up)
|
|
{
|
|
IncrementVarSublevelsUp_context context;
|
|
|
|
context.delta_sublevels_up = delta_sublevels_up;
|
|
context.min_sublevels_up = min_sublevels_up;
|
|
|
|
/*
|
|
* Must be prepared to start with a Query or a bare expression tree;
|
|
* if it's a Query, go straight to query_tree_walker to make sure that
|
|
* sublevels_up doesn't get incremented prematurely.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
query_tree_walker((Query *) node, IncrementVarSublevelsUp_walker,
|
|
(void *) &context, true);
|
|
else
|
|
IncrementVarSublevelsUp_walker(node, &context);
|
|
}
|
|
|
|
|
|
/*
|
|
* rangeTableEntry_used - detect whether an RTE is referenced somewhere
|
|
* in var nodes or join or setOp trees of a query or expression.
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
int rt_index;
|
|
int sublevels_up;
|
|
} rangeTableEntry_used_context;
|
|
|
|
static bool
|
|
rangeTableEntry_used_walker(Node *node,
|
|
rangeTableEntry_used_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
|
|
if (var->varlevelsup == context->sublevels_up &&
|
|
var->varno == context->rt_index)
|
|
return true;
|
|
return false;
|
|
}
|
|
if (IsA(node, RangeTblRef))
|
|
{
|
|
RangeTblRef *rtr = (RangeTblRef *) node;
|
|
|
|
if (rtr->rtindex == context->rt_index &&
|
|
context->sublevels_up == 0)
|
|
return true;
|
|
/* the subquery itself is visited separately */
|
|
return false;
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
/* Recurse into subselects */
|
|
bool result;
|
|
|
|
context->sublevels_up++;
|
|
result = query_tree_walker((Query *) node, rangeTableEntry_used_walker,
|
|
(void *) context, true);
|
|
context->sublevels_up--;
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, rangeTableEntry_used_walker,
|
|
(void *) context);
|
|
}
|
|
|
|
bool
|
|
rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
|
|
{
|
|
rangeTableEntry_used_context context;
|
|
|
|
context.rt_index = rt_index;
|
|
context.sublevels_up = sublevels_up;
|
|
|
|
/*
|
|
* Must be prepared to start with a Query or a bare expression tree;
|
|
* if it's a Query, go straight to query_tree_walker to make sure that
|
|
* sublevels_up doesn't get incremented prematurely.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
return query_tree_walker((Query *) node, rangeTableEntry_used_walker,
|
|
(void *) &context, true);
|
|
else
|
|
return rangeTableEntry_used_walker(node, &context);
|
|
}
|
|
|
|
|
|
/*
|
|
* attribute_used -
|
|
* Check if a specific attribute number of a RTE is used
|
|
* somewhere in the query or expression.
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
int rt_index;
|
|
int attno;
|
|
int sublevels_up;
|
|
} attribute_used_context;
|
|
|
|
static bool
|
|
attribute_used_walker(Node *node,
|
|
attribute_used_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
|
|
if (var->varlevelsup == context->sublevels_up &&
|
|
var->varno == context->rt_index &&
|
|
var->varattno == context->attno)
|
|
return true;
|
|
return false;
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
/* Recurse into subselects */
|
|
bool result;
|
|
|
|
context->sublevels_up++;
|
|
result = query_tree_walker((Query *) node, attribute_used_walker,
|
|
(void *) context, true);
|
|
context->sublevels_up--;
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, attribute_used_walker,
|
|
(void *) context);
|
|
}
|
|
|
|
bool
|
|
attribute_used(Node *node, int rt_index, int attno, int sublevels_up)
|
|
{
|
|
attribute_used_context context;
|
|
|
|
context.rt_index = rt_index;
|
|
context.attno = attno;
|
|
context.sublevels_up = sublevels_up;
|
|
|
|
/*
|
|
* Must be prepared to start with a Query or a bare expression tree;
|
|
* if it's a Query, go straight to query_tree_walker to make sure that
|
|
* sublevels_up doesn't get incremented prematurely.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
return query_tree_walker((Query *) node, attribute_used_walker,
|
|
(void *) &context, true);
|
|
else
|
|
return attribute_used_walker(node, &context);
|
|
}
|
|
|
|
|
|
/*
|
|
* Add the given qualifier condition to the query's WHERE clause
|
|
*/
|
|
void
|
|
AddQual(Query *parsetree, Node *qual)
|
|
{
|
|
Node *copy;
|
|
|
|
if (qual == NULL)
|
|
return;
|
|
|
|
/* INTERSECT want's the original, but we need to copy - Jan */
|
|
copy = copyObject(qual);
|
|
|
|
parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
|
|
copy);
|
|
|
|
/*
|
|
* Make sure query is marked correctly if added qual has sublinks or
|
|
* aggregates (not sure it can ever have aggs, but sublinks
|
|
* definitely).
|
|
*/
|
|
parsetree->hasAggs |= checkExprHasAggs(copy);
|
|
parsetree->hasSubLinks |= checkExprHasSubLink(copy);
|
|
}
|
|
|
|
/*
|
|
* Add the given havingQual to the one already contained in the parsetree
|
|
* just as AddQual does for the normal 'where' qual
|
|
*/
|
|
void
|
|
AddHavingQual(Query *parsetree, Node *havingQual)
|
|
{
|
|
Node *copy;
|
|
|
|
if (havingQual == NULL)
|
|
return;
|
|
|
|
/* INTERSECT want's the original, but we need to copy - Jan */
|
|
copy = copyObject(havingQual);
|
|
|
|
parsetree->havingQual = make_and_qual(parsetree->havingQual,
|
|
copy);
|
|
|
|
/*
|
|
* Make sure query is marked correctly if added qual has sublinks or
|
|
* aggregates (not sure it can ever have aggs, but sublinks
|
|
* definitely).
|
|
*/
|
|
parsetree->hasAggs |= checkExprHasAggs(copy);
|
|
parsetree->hasSubLinks |= checkExprHasSubLink(copy);
|
|
}
|
|
|
|
#ifdef NOT_USED
|
|
void
|
|
AddNotHavingQual(Query *parsetree, Node *havingQual)
|
|
{
|
|
Node *notqual;
|
|
|
|
if (havingQual == NULL)
|
|
return;
|
|
|
|
/* Need not copy input qual, because AddHavingQual will... */
|
|
notqual = (Node *) make_notclause((Expr *) havingQual);
|
|
|
|
AddHavingQual(parsetree, notqual);
|
|
}
|
|
|
|
#endif
|
|
|
|
void
|
|
AddNotQual(Query *parsetree, Node *qual)
|
|
{
|
|
Node *notqual;
|
|
|
|
if (qual == NULL)
|
|
return;
|
|
|
|
/* Need not copy input qual, because AddQual will... */
|
|
notqual = (Node *) make_notclause((Expr *) qual);
|
|
|
|
AddQual(parsetree, notqual);
|
|
}
|
|
|
|
|
|
/* Build a NULL constant expression of the given type */
|
|
static Node *
|
|
make_null(Oid type)
|
|
{
|
|
Const *c = makeNode(Const);
|
|
|
|
c->consttype = type;
|
|
c->constlen = get_typlen(type);
|
|
c->constvalue = PointerGetDatum(NULL);
|
|
c->constisnull = true;
|
|
c->constbyval = get_typbyval(type);
|
|
return (Node *) c;
|
|
}
|
|
|
|
/* Find a targetlist entry by resno */
|
|
static Node *
|
|
FindMatchingNew(List *tlist, int attno)
|
|
{
|
|
List *i;
|
|
|
|
foreach(i, tlist)
|
|
{
|
|
TargetEntry *tle = lfirst(i);
|
|
|
|
if (tle->resdom->resno == attno)
|
|
return tle->expr;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef NOT_USED
|
|
|
|
/* Find a targetlist entry by resname */
|
|
static Node *
|
|
FindMatchingTLEntry(List *tlist, char *e_attname)
|
|
{
|
|
List *i;
|
|
|
|
foreach(i, tlist)
|
|
{
|
|
TargetEntry *tle = lfirst(i);
|
|
char *resname;
|
|
|
|
resname = tle->resdom->resname;
|
|
if (strcmp(e_attname, resname) == 0)
|
|
return tle->expr;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
* ResolveNew - replace Vars with corresponding items from a targetlist
|
|
*
|
|
* Vars matching target_varno and sublevels_up are replaced by the
|
|
* entry with matching resno from targetlist, if there is one.
|
|
* If not, we either change the unmatched Var's varno to update_varno
|
|
* (when event == CMD_UPDATE) or replace it with a constant NULL.
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
int target_varno;
|
|
int sublevels_up;
|
|
List *targetlist;
|
|
int event;
|
|
int update_varno;
|
|
} ResolveNew_context;
|
|
|
|
static Node *
|
|
ResolveNew_mutator(Node *node, ResolveNew_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return NULL;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
int this_varno = (int) var->varno;
|
|
int this_varlevelsup = (int) var->varlevelsup;
|
|
|
|
if (this_varno == context->target_varno &&
|
|
this_varlevelsup == context->sublevels_up)
|
|
{
|
|
Node *n = FindMatchingNew(context->targetlist,
|
|
var->varattno);
|
|
|
|
if (n == NULL)
|
|
{
|
|
if (context->event == CMD_UPDATE)
|
|
{
|
|
/* For update, just change unmatched var's varno */
|
|
var = (Var *) copyObject(node);
|
|
var->varno = context->update_varno;
|
|
var->varnoold = context->update_varno;
|
|
return (Node *) var;
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise replace unmatched var with a null */
|
|
return make_null(var->vartype);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Make a copy of the tlist item to return */
|
|
n = copyObject(n);
|
|
/* Adjust varlevelsup if tlist item is from higher query */
|
|
if (this_varlevelsup > 0)
|
|
IncrementVarSublevelsUp(n, this_varlevelsup, 0);
|
|
return n;
|
|
}
|
|
}
|
|
/* otherwise fall through to copy the var normally */
|
|
}
|
|
|
|
/*
|
|
* Since expression_tree_mutator won't touch subselects, we have to
|
|
* handle them specially.
|
|
*/
|
|
if (IsA(node, SubLink))
|
|
{
|
|
SubLink *sublink = (SubLink *) node;
|
|
SubLink *newnode;
|
|
|
|
FLATCOPY(newnode, sublink, SubLink);
|
|
MUTATE(newnode->lefthand, sublink->lefthand, List *,
|
|
ResolveNew_mutator, context);
|
|
MUTATE(newnode->subselect, sublink->subselect, Node *,
|
|
ResolveNew_mutator, context);
|
|
return (Node *) newnode;
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
Query *query = (Query *) node;
|
|
Query *newnode;
|
|
|
|
FLATCOPY(newnode, query, Query);
|
|
context->sublevels_up++;
|
|
query_tree_mutator(newnode, ResolveNew_mutator, context, true);
|
|
context->sublevels_up--;
|
|
return (Node *) newnode;
|
|
}
|
|
return expression_tree_mutator(node, ResolveNew_mutator,
|
|
(void *) context);
|
|
}
|
|
|
|
Node *
|
|
ResolveNew(Node *node, int target_varno, int sublevels_up,
|
|
List *targetlist, int event, int update_varno)
|
|
{
|
|
ResolveNew_context context;
|
|
|
|
context.target_varno = target_varno;
|
|
context.sublevels_up = sublevels_up;
|
|
context.targetlist = targetlist;
|
|
context.event = event;
|
|
context.update_varno = update_varno;
|
|
|
|
/*
|
|
* Must be prepared to start with a Query or a bare expression tree;
|
|
* if it's a Query, go straight to query_tree_mutator to make sure that
|
|
* sublevels_up doesn't get incremented prematurely.
|
|
*/
|
|
if (node && IsA(node, Query))
|
|
{
|
|
Query *query = (Query *) node;
|
|
Query *newnode;
|
|
|
|
FLATCOPY(newnode, query, Query);
|
|
query_tree_mutator(newnode, ResolveNew_mutator,
|
|
(void *) &context, true);
|
|
return (Node *) newnode;
|
|
}
|
|
else
|
|
return ResolveNew_mutator(node, &context);
|
|
}
|
|
|
|
/*
|
|
* Alternate interface to ResolveNew: substitute Vars in info->rule_action
|
|
* with targetlist items from the parsetree's targetlist.
|
|
*/
|
|
void
|
|
FixNew(RewriteInfo *info, Query *parsetree)
|
|
{
|
|
ResolveNew_context context;
|
|
|
|
context.target_varno = info->new_varno;
|
|
context.sublevels_up = 0;
|
|
context.targetlist = parsetree->targetList;
|
|
context.event = info->event;
|
|
context.update_varno = info->current_varno;
|
|
|
|
query_tree_mutator(info->rule_action, ResolveNew_mutator,
|
|
(void *) &context, true);
|
|
}
|
|
|
|
|
|
#ifdef NOT_USED
|
|
|
|
/*
|
|
* HandleRIRAttributeRule
|
|
* Replace Vars matching a given RT index with copies of TL expressions.
|
|
*
|
|
* Handles 'on retrieve to relation.attribute
|
|
* do instead retrieve (attribute = expression) w/qual'
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
List *rtable;
|
|
List *targetlist;
|
|
int rt_index;
|
|
int attr_num;
|
|
int *modified;
|
|
int *badsql;
|
|
int sublevels_up;
|
|
} HandleRIRAttributeRule_context;
|
|
|
|
static Node *
|
|
HandleRIRAttributeRule_mutator(Node *node,
|
|
HandleRIRAttributeRule_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return NULL;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
int this_varno = var->varno;
|
|
int this_varattno = var->varattno;
|
|
int this_varlevelsup = var->varlevelsup;
|
|
|
|
if (this_varno == context->rt_index &&
|
|
this_varattno == context->attr_num &&
|
|
this_varlevelsup == context->sublevels_up)
|
|
{
|
|
if (var->vartype == 32)
|
|
{ /* HACK: disallow SET variables */
|
|
*context->modified = TRUE;
|
|
*context->badsql = TRUE;
|
|
return make_null(var->vartype);
|
|
}
|
|
else
|
|
{
|
|
char *name_to_look_for;
|
|
|
|
name_to_look_for = get_attname(getrelid(this_varno,
|
|
context->rtable),
|
|
this_varattno);
|
|
if (name_to_look_for)
|
|
{
|
|
Node *n;
|
|
|
|
*context->modified = TRUE;
|
|
n = FindMatchingTLEntry(context->targetlist,
|
|
name_to_look_for);
|
|
if (n == NULL)
|
|
return make_null(var->vartype);
|
|
/* Make a copy of the tlist item to return */
|
|
n = copyObject(n);
|
|
|
|
/*
|
|
* Adjust varlevelsup if tlist item is from higher
|
|
* query
|
|
*/
|
|
if (this_varlevelsup > 0)
|
|
IncrementVarSublevelsUp(n, this_varlevelsup, 0);
|
|
return n;
|
|
}
|
|
}
|
|
}
|
|
/* otherwise fall through to copy the var normally */
|
|
}
|
|
|
|
/*
|
|
* Since expression_tree_mutator won't touch subselects, we have to
|
|
* handle them specially.
|
|
*/
|
|
if (IsA(node, SubLink))
|
|
{
|
|
SubLink *sublink = (SubLink *) node;
|
|
SubLink *newnode;
|
|
|
|
FLATCOPY(newnode, sublink, SubLink);
|
|
MUTATE(newnode->lefthand, sublink->lefthand, List *,
|
|
HandleRIRAttributeRule_mutator, context);
|
|
MUTATE(newnode->subselect, sublink->subselect, Node *,
|
|
HandleRIRAttributeRule_mutator, context);
|
|
return (Node *) newnode;
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
Query *query = (Query *) node;
|
|
Query *newnode;
|
|
|
|
FLATCOPY(newnode, query, Query);
|
|
context->sublevels_up++;
|
|
query_tree_mutator(newnode, HandleRIRAttributeRule_mutator,
|
|
context, true);
|
|
context->sublevels_up--;
|
|
return (Node *) newnode;
|
|
}
|
|
return expression_tree_mutator(node, HandleRIRAttributeRule_mutator,
|
|
(void *) context);
|
|
}
|
|
|
|
void
|
|
HandleRIRAttributeRule(Query *parsetree,
|
|
List *rtable,
|
|
List *targetlist,
|
|
int rt_index,
|
|
int attr_num,
|
|
int *modified,
|
|
int *badsql)
|
|
{
|
|
HandleRIRAttributeRule_context context;
|
|
|
|
context.rtable = rtable;
|
|
context.targetlist = targetlist;
|
|
context.rt_index = rt_index;
|
|
context.attr_num = attr_num;
|
|
context.modified = modified;
|
|
context.badsql = badsql;
|
|
context.sublevels_up = 0;
|
|
|
|
query_tree_mutator(parsetree, HandleRIRAttributeRule_mutator,
|
|
(void *) &context, true);
|
|
}
|
|
|
|
#endif /* NOT_USED */
|