mirror of
https://github.com/postgres/postgres.git
synced 2025-06-26 12:21:12 +03:00
pgindent run. Make it all clean.
This commit is contained in:
Bruce Momjian
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.58 2001/01/24 19:43:05 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.59 2001/03/22 03:59:43 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -175,9 +175,10 @@ DefineQueryRewrite(RuleStmt *stmt)
|
||||
/*
|
||||
* If we are installing an ON SELECT rule, we had better grab
|
||||
* AccessExclusiveLock to ensure no SELECTs are currently running on
|
||||
* the event relation. For other types of rules, it might be sufficient
|
||||
* to grab ShareLock to lock out insert/update/delete actions. But
|
||||
* for now, let's just grab AccessExclusiveLock all the time.
|
||||
* the event relation. For other types of rules, it might be
|
||||
* sufficient to grab ShareLock to lock out insert/update/delete
|
||||
* actions. But for now, let's just grab AccessExclusiveLock all the
|
||||
* time.
|
||||
*/
|
||||
event_relation = heap_openr(event_obj->relname, AccessExclusiveLock);
|
||||
ev_relid = RelationGetRelid(event_relation);
|
||||
@ -226,7 +227,7 @@ DefineQueryRewrite(RuleStmt *stmt)
|
||||
{
|
||||
List *tllist;
|
||||
int i;
|
||||
char *expected_name;
|
||||
char *expected_name;
|
||||
|
||||
/*
|
||||
* So there cannot be INSTEAD NOTHING, ...
|
||||
@ -285,9 +286,10 @@ DefineQueryRewrite(RuleStmt *stmt)
|
||||
|
||||
/*
|
||||
* Allow typmods to be different only if one of them is -1,
|
||||
* ie, "unspecified". This is necessary for cases like "numeric",
|
||||
* where the table will have a filled-in default length but the
|
||||
* select rule's expression will probably have typmod = -1.
|
||||
* ie, "unspecified". This is necessary for cases like
|
||||
* "numeric", where the table will have a filled-in default
|
||||
* length but the select rule's expression will probably have
|
||||
* typmod = -1.
|
||||
*/
|
||||
if (attr->atttypmod != resdom->restypmod &&
|
||||
attr->atttypmod != -1 && resdom->restypmod != -1)
|
||||
@ -327,13 +329,13 @@ DefineQueryRewrite(RuleStmt *stmt)
|
||||
/*
|
||||
* Are we converting a relation to a view?
|
||||
*
|
||||
* If so, check that the relation is empty because the storage
|
||||
* for the relation is going to be deleted.
|
||||
* If so, check that the relation is empty because the storage for
|
||||
* the relation is going to be deleted.
|
||||
*/
|
||||
if (event_relation->rd_rel->relkind != RELKIND_VIEW)
|
||||
{
|
||||
HeapScanDesc scanDesc;
|
||||
HeapTuple tuple;
|
||||
HeapScanDesc scanDesc;
|
||||
HeapTuple tuple;
|
||||
|
||||
scanDesc = heap_beginscan(event_relation, 0, SnapshotNow, 0, NULL);
|
||||
tuple = heap_getnext(scanDesc, 0);
|
||||
@ -341,7 +343,10 @@ DefineQueryRewrite(RuleStmt *stmt)
|
||||
elog(ERROR, "Relation \"%s\" is not empty. Cannot convert it to view",
|
||||
event_obj->relname);
|
||||
|
||||
/* don't need heap_freetuple because we never got a valid tuple */
|
||||
/*
|
||||
* don't need heap_freetuple because we never got a valid
|
||||
* tuple
|
||||
*/
|
||||
heap_endscan(scanDesc);
|
||||
|
||||
RelisBecomingView = true;
|
||||
@ -368,10 +373,10 @@ DefineQueryRewrite(RuleStmt *stmt)
|
||||
is_instead, event_attype);
|
||||
|
||||
/*
|
||||
* We want the rule's table references to be checked as though by
|
||||
* the rule owner, not the user referencing the rule. Therefore,
|
||||
* scan through the rule's rtables and set the checkAsUser field
|
||||
* on all rtable entries (except *OLD* and *NEW*).
|
||||
* We want the rule's table references to be checked as though by the
|
||||
* rule owner, not the user referencing the rule. Therefore, scan
|
||||
* through the rule's rtables and set the checkAsUser field on all
|
||||
* rtable entries (except *OLD* and *NEW*).
|
||||
*/
|
||||
foreach(l, action)
|
||||
{
|
||||
@ -394,21 +399,21 @@ DefineQueryRewrite(RuleStmt *stmt)
|
||||
actionP);
|
||||
|
||||
/*
|
||||
* Set pg_class 'relhasrules' field TRUE for event relation.
|
||||
* If appropriate, also modify the 'relkind' field to show that
|
||||
* the relation is now a view.
|
||||
* Set pg_class 'relhasrules' field TRUE for event relation. If
|
||||
* appropriate, also modify the 'relkind' field to show that the
|
||||
* relation is now a view.
|
||||
*
|
||||
* Important side effect: an SI notice is broadcast to force all
|
||||
* backends (including me!) to update relcache entries with the new
|
||||
* rule.
|
||||
* backends (including me!) to update relcache entries with the
|
||||
* new rule.
|
||||
*/
|
||||
SetRelationRuleStatus(ev_relid, true, RelisBecomingView);
|
||||
}
|
||||
|
||||
/*
|
||||
* IF the relation is becoming a view, delete the storage
|
||||
* files associated with it. NB: we had better have AccessExclusiveLock
|
||||
* to do this ...
|
||||
* IF the relation is becoming a view, delete the storage files
|
||||
* associated with it. NB: we had better have AccessExclusiveLock to
|
||||
* do this ...
|
||||
*/
|
||||
if (RelisBecomingView)
|
||||
smgrunlink(DEFAULT_SMGR, event_relation);
|
||||
@ -439,21 +444,20 @@ setRuleCheckAsUser(Query *qry, Oid userid)
|
||||
|
||||
if (rte->subquery)
|
||||
{
|
||||
|
||||
/*
|
||||
* Recurse into subquery in FROM
|
||||
*/
|
||||
setRuleCheckAsUser(rte->subquery, userid);
|
||||
}
|
||||
else
|
||||
{
|
||||
rte->checkAsUser = userid;
|
||||
}
|
||||
}
|
||||
|
||||
/* If there are sublinks, search for them and process their RTEs */
|
||||
if (qry->hasSubLinks)
|
||||
query_tree_walker(qry, setRuleCheckAsUser_walker, (void *) &userid,
|
||||
false /* already did the ones in rtable */);
|
||||
false /* already did the ones in rtable */ );
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.89 2001/01/27 04:40:59 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.90 2001/03/22 03:59:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -40,7 +40,7 @@ static RewriteInfo *gatherRewriteMeta(Query *parsetree,
|
||||
static List *adjustJoinTreeList(Query *parsetree, bool removert, int rt_index);
|
||||
static void markQueryForUpdate(Query *qry, bool skipOldNew);
|
||||
static List *matchLocks(CmdType event, RuleLock *rulelocks,
|
||||
int varno, Query *parsetree);
|
||||
int varno, Query *parsetree);
|
||||
static Query *fireRIRrules(Query *parsetree);
|
||||
|
||||
|
||||
@ -84,9 +84,9 @@ gatherRewriteMeta(Query *parsetree,
|
||||
* Adjust rule action and qual to offset its varnos, so that we can
|
||||
* merge its rtable into the main parsetree's rtable.
|
||||
*
|
||||
* If the rule action is an INSERT...SELECT, the OLD/NEW rtable
|
||||
* entries will be in the SELECT part, and we have to modify that
|
||||
* rather than the top-level INSERT (kluge!).
|
||||
* If the rule action is an INSERT...SELECT, the OLD/NEW rtable entries
|
||||
* will be in the SELECT part, and we have to modify that rather than
|
||||
* the top-level INSERT (kluge!).
|
||||
*/
|
||||
sub_action = getInsertSelectQuery(info->rule_action, &sub_action_ptr);
|
||||
|
||||
@ -101,14 +101,14 @@ gatherRewriteMeta(Query *parsetree,
|
||||
/*
|
||||
* We want the main parsetree's rtable to end up as the concatenation
|
||||
* of its original contents plus those of all the relevant rule
|
||||
* actions. Also store same into all the rule_action rtables.
|
||||
* Some of the entries may be unused after we finish rewriting, but
|
||||
* if we tried to clean those out we'd have a much harder job to
|
||||
* adjust RT indexes in the query's Vars. It's OK to have unused
|
||||
* RT entries, since planner will ignore them.
|
||||
* actions. Also store same into all the rule_action rtables. Some of
|
||||
* the entries may be unused after we finish rewriting, but if we
|
||||
* tried to clean those out we'd have a much harder job to adjust RT
|
||||
* indexes in the query's Vars. It's OK to have unused RT entries,
|
||||
* since planner will ignore them.
|
||||
*
|
||||
* NOTE KLUGY HACK: we assume the parsetree rtable had at least one
|
||||
* entry to begin with (OK enough, else where'd the rule come from?).
|
||||
* NOTE KLUGY HACK: we assume the parsetree rtable had at least one entry
|
||||
* to begin with (OK enough, else where'd the rule come from?).
|
||||
* Because of this, if multiple rules nconc() their rtable additions
|
||||
* onto parsetree->rtable, they'll all see the same rtable because
|
||||
* they all have the same list head pointer.
|
||||
@ -119,24 +119,25 @@ gatherRewriteMeta(Query *parsetree,
|
||||
|
||||
/*
|
||||
* Each rule action's jointree should be the main parsetree's jointree
|
||||
* plus that rule's jointree, but usually *without* the original rtindex
|
||||
* that we're replacing (if present, which it won't be for INSERT).
|
||||
* Note that if the rule action refers to OLD, its jointree will add
|
||||
* a reference to rt_index. If the rule action doesn't refer to OLD,
|
||||
* but either the rule_qual or the user query quals do, then we need to
|
||||
* keep the original rtindex in the jointree to provide data for the
|
||||
* quals. We don't want the original rtindex to be joined twice,
|
||||
* however, so avoid keeping it if the rule action mentions it.
|
||||
* plus that rule's jointree, but usually *without* the original
|
||||
* rtindex that we're replacing (if present, which it won't be for
|
||||
* INSERT). Note that if the rule action refers to OLD, its jointree
|
||||
* will add a reference to rt_index. If the rule action doesn't refer
|
||||
* to OLD, but either the rule_qual or the user query quals do, then
|
||||
* we need to keep the original rtindex in the jointree to provide
|
||||
* data for the quals. We don't want the original rtindex to be
|
||||
* joined twice, however, so avoid keeping it if the rule action
|
||||
* mentions it.
|
||||
*/
|
||||
if (sub_action->jointree != NULL)
|
||||
{
|
||||
bool keeporig;
|
||||
List *newjointree;
|
||||
bool keeporig;
|
||||
List *newjointree;
|
||||
|
||||
keeporig = (! rangeTableEntry_used((Node *) sub_action->jointree,
|
||||
rt_index, 0)) &&
|
||||
keeporig = (!rangeTableEntry_used((Node *) sub_action->jointree,
|
||||
rt_index, 0)) &&
|
||||
(rangeTableEntry_used(info->rule_qual, rt_index, 0) ||
|
||||
rangeTableEntry_used(parsetree->jointree->quals, rt_index, 0));
|
||||
rangeTableEntry_used(parsetree->jointree->quals, rt_index, 0));
|
||||
newjointree = adjustJoinTreeList(parsetree, !keeporig, rt_index);
|
||||
sub_action->jointree->fromlist =
|
||||
nconc(newjointree, sub_action->jointree->fromlist);
|
||||
@ -154,17 +155,17 @@ gatherRewriteMeta(Query *parsetree,
|
||||
parsetree->hasSubLinks = TRUE;
|
||||
|
||||
/*
|
||||
* Event Qualification forces copying of parsetree and
|
||||
* splitting into two queries one w/rule_qual, one w/NOT
|
||||
* rule_qual. Also add user query qual onto rule action
|
||||
* Event Qualification forces copying of parsetree and splitting into
|
||||
* two queries one w/rule_qual, one w/NOT rule_qual. Also add user
|
||||
* query qual onto rule action
|
||||
*/
|
||||
AddQual(sub_action, info->rule_qual);
|
||||
|
||||
AddQual(sub_action, parsetree->jointree->quals);
|
||||
|
||||
/*
|
||||
* Rewrite new.attribute w/ right hand side of target-list
|
||||
* entry for appropriate field name in insert/update.
|
||||
* Rewrite new.attribute w/ right hand side of target-list entry for
|
||||
* appropriate field name in insert/update.
|
||||
*
|
||||
* KLUGE ALERT: since ResolveNew returns a mutated copy, we can't just
|
||||
* apply it to sub_action; we have to remember to update the sublink
|
||||
@ -207,7 +208,7 @@ adjustJoinTreeList(Query *parsetree, bool removert, int rt_index)
|
||||
{
|
||||
RangeTblRef *rtr = lfirst(jjt);
|
||||
|
||||
if (IsA(rtr, RangeTblRef) && rtr->rtindex == rt_index)
|
||||
if (IsA(rtr, RangeTblRef) &&rtr->rtindex == rt_index)
|
||||
{
|
||||
newjointree = lremove(rtr, newjointree);
|
||||
break;
|
||||
@ -278,7 +279,7 @@ ApplyRetrieveRule(Query *parsetree,
|
||||
elog(ERROR, "ApplyRetrieveRule: expected just one rule action");
|
||||
if (rule->qual != NULL)
|
||||
elog(ERROR, "ApplyRetrieveRule: can't handle qualified ON SELECT rule");
|
||||
if (! relation_level)
|
||||
if (!relation_level)
|
||||
elog(ERROR, "ApplyRetrieveRule: can't handle per-attribute ON SELECT rule");
|
||||
|
||||
/*
|
||||
@ -290,8 +291,8 @@ ApplyRetrieveRule(Query *parsetree,
|
||||
rule_action = fireRIRrules(rule_action);
|
||||
|
||||
/*
|
||||
* VIEWs are really easy --- just plug the view query in as a subselect,
|
||||
* replacing the relation's original RTE.
|
||||
* VIEWs are really easy --- just plug the view query in as a
|
||||
* subselect, replacing the relation's original RTE.
|
||||
*/
|
||||
rte = rt_fetch(rt_index, parsetree->rtable);
|
||||
|
||||
@ -317,6 +318,7 @@ ApplyRetrieveRule(Query *parsetree,
|
||||
*/
|
||||
if (intMember(rt_index, parsetree->rowMarks))
|
||||
{
|
||||
|
||||
/*
|
||||
* Remove the view from the list of rels that will actually be
|
||||
* marked FOR UPDATE by the executor. It will still be access-
|
||||
@ -399,6 +401,7 @@ fireRIRonSubLink(Node *node, void *context)
|
||||
sub->subselect = (Node *) fireRIRrules((Query *) (sub->subselect));
|
||||
/* Fall through to process lefthand args of SubLink */
|
||||
}
|
||||
|
||||
/*
|
||||
* Do NOT recurse into Query nodes, because fireRIRrules already
|
||||
* processed subselects of subselects for us.
|
||||
@ -462,17 +465,17 @@ fireRIRrules(Query *parsetree)
|
||||
continue;
|
||||
|
||||
/*
|
||||
* This may well be the first access to the relation during
|
||||
* the current statement (it will be, if this Query was extracted
|
||||
* from a rule or somehow got here other than via the parser).
|
||||
* Therefore, grab the appropriate lock type for the relation,
|
||||
* and do not release it until end of transaction. This protects
|
||||
* the rewriter and planner against schema changes mid-query.
|
||||
* This may well be the first access to the relation during the
|
||||
* current statement (it will be, if this Query was extracted from
|
||||
* a rule or somehow got here other than via the parser).
|
||||
* Therefore, grab the appropriate lock type for the relation, and
|
||||
* do not release it until end of transaction. This protects the
|
||||
* rewriter and planner against schema changes mid-query.
|
||||
*
|
||||
* If the relation is the query's result relation, then RewriteQuery()
|
||||
* already got the right lock on it, so we need no additional lock.
|
||||
* Otherwise, check to see if the relation is accessed FOR UPDATE
|
||||
* or not.
|
||||
* If the relation is the query's result relation, then
|
||||
* RewriteQuery() already got the right lock on it, so we need no
|
||||
* additional lock. Otherwise, check to see if the relation is
|
||||
* accessed FOR UPDATE or not.
|
||||
*/
|
||||
if (rt_index == parsetree->resultRelation)
|
||||
lockmode = NoLock;
|
||||
@ -534,14 +537,14 @@ fireRIRrules(Query *parsetree)
|
||||
*/
|
||||
if (parsetree->hasSubLinks)
|
||||
query_tree_walker(parsetree, fireRIRonSubLink, NULL,
|
||||
false /* already handled the ones in rtable */);
|
||||
false /* already handled the ones in rtable */ );
|
||||
|
||||
/*
|
||||
* If the query was marked having aggregates, check if this is
|
||||
* still true after rewriting. Ditto for sublinks. Note there
|
||||
* should be no aggs in the qual at this point. (Does this code
|
||||
* still do anything useful? The view-becomes-subselect-in-FROM
|
||||
* approach doesn't look like it could remove aggs or sublinks...)
|
||||
* If the query was marked having aggregates, check if this is still
|
||||
* true after rewriting. Ditto for sublinks. Note there should be no
|
||||
* aggs in the qual at this point. (Does this code still do anything
|
||||
* useful? The view-becomes-subselect-in-FROM approach doesn't look
|
||||
* like it could remove aggs or sublinks...)
|
||||
*/
|
||||
if (parsetree->hasAggs)
|
||||
{
|
||||
@ -551,9 +554,7 @@ fireRIRrules(Query *parsetree)
|
||||
elog(ERROR, "fireRIRrules: failed to remove aggs from qual");
|
||||
}
|
||||
if (parsetree->hasSubLinks)
|
||||
{
|
||||
parsetree->hasSubLinks = checkExprHasSubLink((Node *) parsetree);
|
||||
}
|
||||
|
||||
return parsetree;
|
||||
}
|
||||
@ -594,7 +595,7 @@ orderRules(List *locks)
|
||||
* This is used to generate suitable "else clauses" for conditional INSTEAD
|
||||
* rules.
|
||||
*
|
||||
* The rule_qual may contain references to OLD or NEW. OLD references are
|
||||
* The rule_qual may contain references to OLD or NEW. OLD references are
|
||||
* replaced by references to the specified rt_index (the relation that the
|
||||
* rule applies to). NEW references are only possible for INSERT and UPDATE
|
||||
* queries on the relation itself, and so they should be replaced by copies
|
||||
@ -769,12 +770,12 @@ RewriteQuery(Query *parsetree, bool *instead_flag, List **qual_products)
|
||||
rt_entry = rt_fetch(result_relation, parsetree->rtable);
|
||||
|
||||
/*
|
||||
* This may well be the first access to the result relation during
|
||||
* the current statement (it will be, if this Query was extracted
|
||||
* from a rule or somehow got here other than via the parser).
|
||||
* Therefore, grab the appropriate lock type for a result relation,
|
||||
* and do not release it until end of transaction. This protects the
|
||||
* rewriter and planner against schema changes mid-query.
|
||||
* This may well be the first access to the result relation during the
|
||||
* current statement (it will be, if this Query was extracted from a
|
||||
* rule or somehow got here other than via the parser). Therefore,
|
||||
* grab the appropriate lock type for a result relation, and do not
|
||||
* release it until end of transaction. This protects the rewriter
|
||||
* and planner against schema changes mid-query.
|
||||
*/
|
||||
rt_entry_relation = heap_openr(rt_entry->relname, RowExclusiveLock);
|
||||
|
||||
@ -793,7 +794,7 @@ RewriteQuery(Query *parsetree, bool *instead_flag, List **qual_products)
|
||||
qual_products);
|
||||
}
|
||||
|
||||
heap_close(rt_entry_relation, NoLock); /* keep lock! */
|
||||
heap_close(rt_entry_relation, NoLock); /* keep lock! */
|
||||
|
||||
return product_queries;
|
||||
}
|
||||
@ -912,7 +913,7 @@ QueryRewrite(Query *parsetree)
|
||||
*/
|
||||
foreach(l, querylist)
|
||||
{
|
||||
Query *query = (Query *) lfirst(l);
|
||||
Query *query = (Query *) lfirst(l);
|
||||
|
||||
query = fireRIRrules(query);
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.55 2001/01/27 01:44:20 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.56 2001/03/22 03:59:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -43,9 +43,10 @@ static bool checkExprHasSubLink_walker(Node *node, void *context);
|
||||
bool
|
||||
checkExprHasAggs(Node *node)
|
||||
{
|
||||
|
||||
/*
|
||||
* If a Query is passed, examine it --- but we will not recurse
|
||||
* into sub-Queries.
|
||||
* 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,
|
||||
@ -73,9 +74,10 @@ checkExprHasAggs_walker(Node *node, void *context)
|
||||
bool
|
||||
checkExprHasSubLink(Node *node)
|
||||
{
|
||||
|
||||
/*
|
||||
* If a Query is passed, examine it --- but we will not recurse
|
||||
* into sub-Queries.
|
||||
* 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,
|
||||
@ -101,7 +103,7 @@ checkExprHasSubLink_walker(Node *node, void *context)
|
||||
*
|
||||
* 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
|
||||
* 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
|
||||
@ -133,7 +135,7 @@ OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
|
||||
}
|
||||
if (IsA(node, RangeTblRef))
|
||||
{
|
||||
RangeTblRef *rtr = (RangeTblRef *) node;
|
||||
RangeTblRef *rtr = (RangeTblRef *) node;
|
||||
|
||||
if (context->sublevels_up == 0)
|
||||
rtr->rtindex += context->offset;
|
||||
@ -170,24 +172,22 @@ OffsetVarNodes(Node *node, int offset, int sublevels_up)
|
||||
*/
|
||||
if (node && IsA(node, Query))
|
||||
{
|
||||
Query *qry = (Query *) node;
|
||||
List *l;
|
||||
Query *qry = (Query *) node;
|
||||
List *l;
|
||||
|
||||
/*
|
||||
* If we are starting at a Query, and sublevels_up is zero, then we
|
||||
* must also fix rangetable indexes in the Query itself --- namely
|
||||
* resultRelation and rowMarks entries. sublevels_up cannot be zero
|
||||
* when recursing into a subquery, so there's no need to have the
|
||||
* same logic inside OffsetVarNodes_walker.
|
||||
* If we are starting at a Query, and sublevels_up is zero, then
|
||||
* we must also fix rangetable indexes in the Query itself ---
|
||||
* namely resultRelation and rowMarks entries. sublevels_up
|
||||
* cannot be zero when recursing into a subquery, so there's no
|
||||
* need to have the same logic inside OffsetVarNodes_walker.
|
||||
*/
|
||||
if (sublevels_up == 0)
|
||||
{
|
||||
if (qry->resultRelation)
|
||||
qry->resultRelation += offset;
|
||||
foreach(l, qry->rowMarks)
|
||||
{
|
||||
lfirsti(l) += offset;
|
||||
}
|
||||
}
|
||||
query_tree_walker(qry, OffsetVarNodes_walker,
|
||||
(void *) &context, true);
|
||||
@ -235,7 +235,7 @@ ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
|
||||
}
|
||||
if (IsA(node, RangeTblRef))
|
||||
{
|
||||
RangeTblRef *rtr = (RangeTblRef *) node;
|
||||
RangeTblRef *rtr = (RangeTblRef *) node;
|
||||
|
||||
if (context->sublevels_up == 0 &&
|
||||
rtr->rtindex == context->rt_index)
|
||||
@ -274,15 +274,15 @@ ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
|
||||
*/
|
||||
if (node && IsA(node, Query))
|
||||
{
|
||||
Query *qry = (Query *) node;
|
||||
List *l;
|
||||
Query *qry = (Query *) node;
|
||||
List *l;
|
||||
|
||||
/*
|
||||
* If we are starting at a Query, and sublevels_up is zero, then we
|
||||
* must also fix rangetable indexes in the Query itself --- namely
|
||||
* resultRelation and rowMarks entries. sublevels_up cannot be zero
|
||||
* when recursing into a subquery, so there's no need to have the
|
||||
* same logic inside ChangeVarNodes_walker.
|
||||
* If we are starting at a Query, and sublevels_up is zero, then
|
||||
* we must also fix rangetable indexes in the Query itself ---
|
||||
* namely resultRelation and rowMarks entries. sublevels_up
|
||||
* cannot be zero when recursing into a subquery, so there's no
|
||||
* need to have the same logic inside ChangeVarNodes_walker.
|
||||
*/
|
||||
if (sublevels_up == 0)
|
||||
{
|
||||
@ -541,11 +541,12 @@ getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
|
||||
return parsetree;
|
||||
if (parsetree->commandType != CMD_INSERT)
|
||||
return parsetree;
|
||||
|
||||
/*
|
||||
* Currently, this is ONLY applied to rule-action queries, and so
|
||||
* we expect to find the *OLD* and *NEW* placeholder entries in the
|
||||
* given query. If they're not there, it must be an INSERT/SELECT
|
||||
* in which they've been pushed down to the SELECT.
|
||||
* Currently, this is ONLY applied to rule-action queries, and so we
|
||||
* expect to find the *OLD* and *NEW* placeholder entries in the given
|
||||
* query. If they're not there, it must be an INSERT/SELECT in which
|
||||
* they've been pushed down to the SELECT.
|
||||
*/
|
||||
if (length(parsetree->rtable) >= 2 &&
|
||||
strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->relname,
|
||||
@ -560,17 +561,17 @@ getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
|
||||
Assert(IsA(rtr, RangeTblRef));
|
||||
selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
|
||||
selectquery = selectrte->subquery;
|
||||
if (! (selectquery && IsA(selectquery, Query) &&
|
||||
selectquery->commandType == CMD_SELECT))
|
||||
if (!(selectquery && IsA(selectquery, Query) &&
|
||||
selectquery->commandType == CMD_SELECT))
|
||||
elog(ERROR, "getInsertSelectQuery: expected to find SELECT subquery");
|
||||
if (length(selectquery->rtable) >= 2 &&
|
||||
strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->relname,
|
||||
"*OLD*") == 0 &&
|
||||
strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->relname,
|
||||
"*NEW*") == 0)
|
||||
strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->relname,
|
||||
"*OLD*") == 0 &&
|
||||
strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->relname,
|
||||
"*NEW*") == 0)
|
||||
{
|
||||
if (subquery_ptr)
|
||||
*subquery_ptr = & (selectrte->subquery);
|
||||
*subquery_ptr = &(selectrte->subquery);
|
||||
return selectquery;
|
||||
}
|
||||
elog(ERROR, "getInsertSelectQuery: can't find rule placeholders");
|
||||
@ -591,11 +592,12 @@ AddQual(Query *parsetree, Node *qual)
|
||||
|
||||
if (parsetree->commandType == CMD_UTILITY)
|
||||
{
|
||||
|
||||
/*
|
||||
* Noplace to put the qual on a utility statement.
|
||||
*
|
||||
* For now, we expect utility stmt to be a NOTIFY, so give a
|
||||
* specific error message for that case.
|
||||
* For now, we expect utility stmt to be a NOTIFY, so give a specific
|
||||
* error message for that case.
|
||||
*/
|
||||
if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
|
||||
elog(ERROR, "Conditional NOTIFY is not implemented");
|
||||
@ -632,11 +634,12 @@ AddHavingQual(Query *parsetree, Node *havingQual)
|
||||
|
||||
if (parsetree->commandType == CMD_UTILITY)
|
||||
{
|
||||
|
||||
/*
|
||||
* Noplace to put the qual on a utility statement.
|
||||
*
|
||||
* For now, we expect utility stmt to be a NOTIFY, so give a
|
||||
* specific error message for that case.
|
||||
* For now, we expect utility stmt to be a NOTIFY, so give a specific
|
||||
* error message for that case.
|
||||
*/
|
||||
if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
|
||||
elog(ERROR, "Conditional NOTIFY is not implemented");
|
||||
@ -839,8 +842,8 @@ ResolveNew(Node *node, int target_varno, int 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_mutator to make sure that
|
||||
* sublevels_up doesn't get incremented prematurely.
|
||||
* 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))
|
||||
{
|
||||
@ -876,11 +879,11 @@ typedef struct
|
||||
int *modified;
|
||||
int *badsql;
|
||||
int sublevels_up;
|
||||
} HandleRIRAttributeRule_context;
|
||||
} HandleRIRAttributeRule_context;
|
||||
|
||||
static Node *
|
||||
HandleRIRAttributeRule_mutator(Node *node,
|
||||
HandleRIRAttributeRule_context *context)
|
||||
HandleRIRAttributeRule_context * context)
|
||||
{
|
||||
if (node == NULL)
|
||||
return NULL;
|
||||
@ -988,4 +991,4 @@ HandleRIRAttributeRule(Query *parsetree,
|
||||
(void *) &context, true);
|
||||
}
|
||||
|
||||
#endif /* NOT_USED */
|
||||
#endif /* NOT_USED */
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.43 2001/01/24 19:43:05 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.44 2001/03/22 03:59:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -42,7 +42,7 @@ RewriteGetRuleEventRel(char *rulename)
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(htup))
|
||||
elog(ERROR, "Rule or view \"%s\" not found",
|
||||
((strncmp(rulename, "_RET", 4) == 0) ? (rulename + 4) : rulename));
|
||||
((strncmp(rulename, "_RET", 4) == 0) ? (rulename + 4) : rulename));
|
||||
eventrel = ((Form_pg_rewrite) GETSTRUCT(htup))->ev_class;
|
||||
ReleaseSysCache(htup);
|
||||
|
||||
@ -102,15 +102,15 @@ RemoveRewriteRule(char *ruleName)
|
||||
|
||||
/*
|
||||
* We had better grab AccessExclusiveLock so that we know no other
|
||||
* rule additions/deletions are going on for this relation. Else
|
||||
* we cannot set relhasrules correctly. Besides, we don't want to
|
||||
* be changing the ruleset while queries are executing on the rel.
|
||||
* rule additions/deletions are going on for this relation. Else we
|
||||
* cannot set relhasrules correctly. Besides, we don't want to be
|
||||
* changing the ruleset while queries are executing on the rel.
|
||||
*/
|
||||
event_relation = heap_open(eventRelationOid, AccessExclusiveLock);
|
||||
|
||||
/* do not allow the removal of a view's SELECT rule */
|
||||
if (event_relation->rd_rel->relkind == RELKIND_VIEW &&
|
||||
((Form_pg_rewrite) GETSTRUCT(tuple))->ev_type == '1' )
|
||||
((Form_pg_rewrite) GETSTRUCT(tuple))->ev_type == '1')
|
||||
elog(ERROR, "Cannot remove a view's SELECT rule");
|
||||
|
||||
hasMoreRules = event_relation->rd_rules != NULL &&
|
||||
@ -133,10 +133,9 @@ RemoveRewriteRule(char *ruleName)
|
||||
/*
|
||||
* Set pg_class 'relhasrules' field correctly for event relation.
|
||||
*
|
||||
* Important side effect: an SI notice is broadcast to force all
|
||||
* backends (including me!) to update relcache entries with the
|
||||
* new rule set. Therefore, must do this even if relhasrules is
|
||||
* still true!
|
||||
* Important side effect: an SI notice is broadcast to force all backends
|
||||
* (including me!) to update relcache entries with the new rule set.
|
||||
* Therefore, must do this even if relhasrules is still true!
|
||||
*/
|
||||
SetRelationRuleStatus(eventRelationOid, hasMoreRules, false);
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.47 2001/01/24 19:43:05 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.48 2001/03/22 03:59:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -52,7 +52,8 @@ SetRelationRuleStatus(Oid relationId, bool relHasRules,
|
||||
Relation idescs[Num_pg_class_indices];
|
||||
|
||||
/*
|
||||
* Find the tuple to update in pg_class, using syscache for the lookup.
|
||||
* Find the tuple to update in pg_class, using syscache for the
|
||||
* lookup.
|
||||
*/
|
||||
relationRelation = heap_openr(RelationRelationName, RowExclusiveLock);
|
||||
tuple = SearchSysCacheCopy(RELOID,
|
||||
|
||||
Reference in New Issue
Block a user