mirror of
https://github.com/postgres/postgres.git
synced 2025-07-30 11:03:19 +03:00
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
This commit is contained in:
Bruce Momjian
@ -6,7 +6,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.3 1997/09/07 04:48:02 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.4 1997/09/08 02:28:15 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -26,52 +26,52 @@
|
||||
* if we find at least one such match, we return true
|
||||
* otherwise, we return false
|
||||
*/
|
||||
static bool
|
||||
static bool
|
||||
nodeThisLockWasTriggered(Node * node, int varno, AttrNumber attnum)
|
||||
{
|
||||
if (node == NULL)
|
||||
return FALSE;
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *) node;
|
||||
|
||||
if (varno == var->varno &&
|
||||
(attnum == var->varattno || attnum == -1))
|
||||
return TRUE;
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
return
|
||||
nodeThisLockWasTriggered((Node *) expr->args, varno, attnum);
|
||||
}
|
||||
break;
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
return
|
||||
nodeThisLockWasTriggered(tle->expr, varno, attnum);
|
||||
}
|
||||
break;
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
case T_Var:
|
||||
{
|
||||
if (nodeThisLockWasTriggered(lfirst(l), varno, attnum))
|
||||
Var *var = (Var *) node;
|
||||
|
||||
if (varno == var->varno &&
|
||||
(attnum == var->varattno || attnum == -1))
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
return
|
||||
nodeThisLockWasTriggered((Node *) expr->args, varno, attnum);
|
||||
}
|
||||
break;
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
return
|
||||
nodeThisLockWasTriggered(tle->expr, varno, attnum);
|
||||
}
|
||||
break;
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
{
|
||||
if (nodeThisLockWasTriggered(lfirst(l), varno, attnum))
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
@ -82,7 +82,7 @@ nodeThisLockWasTriggered(Node * node, int varno, AttrNumber attnum)
|
||||
* against the attnum if we find at least one such match, we return true
|
||||
* otherwise, we return false
|
||||
*/
|
||||
static bool
|
||||
static bool
|
||||
thisLockWasTriggered(int varno,
|
||||
AttrNumber attnum,
|
||||
Query * parsetree)
|
||||
@ -97,15 +97,15 @@ thisLockWasTriggered(int varno,
|
||||
* matchLocks -
|
||||
* match the list of locks and returns the matching rules
|
||||
*/
|
||||
List *
|
||||
List *
|
||||
matchLocks(CmdType event,
|
||||
RuleLock * rulelocks,
|
||||
int varno,
|
||||
Query * parsetree)
|
||||
{
|
||||
List *real_locks = NIL;
|
||||
int nlocks;
|
||||
int i;
|
||||
List *real_locks = NIL;
|
||||
int nlocks;
|
||||
int i;
|
||||
|
||||
Assert(rulelocks != NULL); /* we get called iff there is some lock */
|
||||
Assert(parsetree != NULL);
|
||||
@ -122,7 +122,7 @@ matchLocks(CmdType event,
|
||||
|
||||
for (i = 0; i < nlocks; i++)
|
||||
{
|
||||
RewriteRule *oneLock = rulelocks->rules[i];
|
||||
RewriteRule *oneLock = rulelocks->rules[i];
|
||||
|
||||
if (oneLock->event == event)
|
||||
{
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.4 1997/09/07 04:48:05 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.5 1997/09/08 02:28:16 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -30,7 +30,7 @@
|
||||
#include "rewrite/rewriteSupport.h"
|
||||
#include "tcop/tcopprot.h"
|
||||
|
||||
Oid LastOidProcessed = InvalidOid;
|
||||
Oid LastOidProcessed = InvalidOid;
|
||||
|
||||
/*
|
||||
* This is too small for many rule plans, but it'll have to do for now.
|
||||
@ -43,8 +43,8 @@ Oid LastOidProcessed = InvalidOid;
|
||||
static void
|
||||
strcpyq(char *dest, char *source)
|
||||
{
|
||||
char *current = source,
|
||||
*destp = dest;
|
||||
char *current = source,
|
||||
*destp = dest;
|
||||
|
||||
for (current = source; *current; current++)
|
||||
{
|
||||
@ -75,7 +75,7 @@ strcpyq(char *dest, char *source)
|
||||
* evinstead - is an instead rule
|
||||
* actiontree - parsetree(s) of rule action
|
||||
*/
|
||||
static Oid
|
||||
static Oid
|
||||
InsertRule(char *rulname,
|
||||
int evtype,
|
||||
char *evobj,
|
||||
@ -84,15 +84,15 @@ InsertRule(char *rulname,
|
||||
bool evinstead,
|
||||
char *actiontree)
|
||||
{
|
||||
static char rulebuf[RULE_PLAN_SIZE];
|
||||
static char actionbuf[RULE_PLAN_SIZE];
|
||||
static char qualbuf[RULE_PLAN_SIZE];
|
||||
Oid eventrel_oid = InvalidOid;
|
||||
AttrNumber evslot_index = InvalidAttrNumber;
|
||||
Relation eventrel = NULL;
|
||||
char *is_instead = "f";
|
||||
extern void eval_as_new_xact();
|
||||
char *template;
|
||||
static char rulebuf[RULE_PLAN_SIZE];
|
||||
static char actionbuf[RULE_PLAN_SIZE];
|
||||
static char qualbuf[RULE_PLAN_SIZE];
|
||||
Oid eventrel_oid = InvalidOid;
|
||||
AttrNumber evslot_index = InvalidAttrNumber;
|
||||
Relation eventrel = NULL;
|
||||
char *is_instead = "f";
|
||||
extern void eval_as_new_xact();
|
||||
char *template;
|
||||
|
||||
eventrel = heap_openr(evobj);
|
||||
if (eventrel == NULL)
|
||||
@ -172,7 +172,7 @@ ValidateRule(int event_type,
|
||||
*/
|
||||
if (is_instead && !*action && eslot_string && event_type == CMD_SELECT)
|
||||
{
|
||||
char *temp_buffer = (char *) palloc(strlen(template) + 80);
|
||||
char *temp_buffer = (char *) palloc(strlen(template) + 80);
|
||||
|
||||
sprintf(temp_buffer, template, event_attype,
|
||||
get_typlen(event_attype), eslot_string,
|
||||
@ -188,19 +188,19 @@ ValidateRule(int event_type,
|
||||
void
|
||||
DefineQueryRewrite(RuleStmt * stmt)
|
||||
{
|
||||
CmdType event_type = stmt->event;
|
||||
Attr *event_obj = stmt->object;
|
||||
Node *event_qual = stmt->whereClause;
|
||||
bool is_instead = stmt->instead;
|
||||
List *action = stmt->actions;
|
||||
Relation event_relation = NULL;
|
||||
Oid ruleId;
|
||||
Oid ev_relid = 0;
|
||||
char *eslot_string = NULL;
|
||||
int event_attno = 0;
|
||||
Oid event_attype = 0;
|
||||
char *actionP,
|
||||
*event_qualP;
|
||||
CmdType event_type = stmt->event;
|
||||
Attr *event_obj = stmt->object;
|
||||
Node *event_qual = stmt->whereClause;
|
||||
bool is_instead = stmt->instead;
|
||||
List *action = stmt->actions;
|
||||
Relation event_relation = NULL;
|
||||
Oid ruleId;
|
||||
Oid ev_relid = 0;
|
||||
char *eslot_string = NULL;
|
||||
int event_attno = 0;
|
||||
Oid event_attype = 0;
|
||||
char *actionP,
|
||||
*event_qualP;
|
||||
|
||||
if (event_obj->attrs)
|
||||
eslot_string = strVal(lfirst(event_obj->attrs));
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.4 1997/09/07 04:48:07 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.5 1997/09/08 02:28:17 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -32,10 +32,10 @@
|
||||
static void
|
||||
ApplyRetrieveRule(Query * parsetree, RewriteRule * rule,
|
||||
int rt_index, int relation_level, int *modified);
|
||||
static List *
|
||||
static List *
|
||||
fireRules(Query * parsetree, int rt_index, CmdType event,
|
||||
bool * instead_flag, List * locks, List ** qual_products);
|
||||
static List *deepRewriteQuery(Query * parsetree);
|
||||
static List *deepRewriteQuery(Query * parsetree);
|
||||
|
||||
/*
|
||||
* gatherRewriteMeta -
|
||||
@ -51,9 +51,9 @@ gatherRewriteMeta(Query * parsetree,
|
||||
CmdType event,
|
||||
bool * instead_flag)
|
||||
{
|
||||
RewriteInfo *info;
|
||||
int rt_length;
|
||||
int result_reln;
|
||||
RewriteInfo *info;
|
||||
int rt_length;
|
||||
int result_reln;
|
||||
|
||||
info = (RewriteInfo *) palloc(sizeof(RewriteInfo));
|
||||
info->rt_index = rt_index;
|
||||
@ -90,18 +90,18 @@ gatherRewriteMeta(Query * parsetree,
|
||||
*/
|
||||
if (info->action != CMD_SELECT)
|
||||
{ /* i.e update XXXXX */
|
||||
int new_result_reln = 0;
|
||||
int new_result_reln = 0;
|
||||
|
||||
result_reln = info->rule_action->resultRelation;
|
||||
switch (result_reln)
|
||||
{
|
||||
case PRS2_CURRENT_VARNO:
|
||||
new_result_reln = rt_index;
|
||||
break;
|
||||
case PRS2_NEW_VARNO: /* XXX */
|
||||
default:
|
||||
new_result_reln = result_reln + rt_length;
|
||||
break;
|
||||
case PRS2_CURRENT_VARNO:
|
||||
new_result_reln = rt_index;
|
||||
break;
|
||||
case PRS2_NEW_VARNO: /* XXX */
|
||||
default:
|
||||
new_result_reln = result_reln + rt_length;
|
||||
break;
|
||||
}
|
||||
info->rule_action->resultRelation = new_result_reln;
|
||||
}
|
||||
@ -109,16 +109,16 @@ gatherRewriteMeta(Query * parsetree,
|
||||
return info;
|
||||
}
|
||||
|
||||
static List *
|
||||
static List *
|
||||
OptimizeRIRRules(List * locks)
|
||||
{
|
||||
List *attr_level = NIL,
|
||||
*i;
|
||||
List *relation_level = NIL;
|
||||
List *attr_level = NIL,
|
||||
*i;
|
||||
List *relation_level = NIL;
|
||||
|
||||
foreach(i, locks)
|
||||
{
|
||||
RewriteRule *rule_lock = lfirst(i);
|
||||
RewriteRule *rule_lock = lfirst(i);
|
||||
|
||||
if (rule_lock->attrno == -1)
|
||||
relation_level = lappend(relation_level, rule_lock);
|
||||
@ -132,16 +132,16 @@ OptimizeRIRRules(List * locks)
|
||||
* idea is to put instead rules before regular rules so that
|
||||
* excess semantically queasy queries aren't processed
|
||||
*/
|
||||
static List *
|
||||
static List *
|
||||
orderRules(List * locks)
|
||||
{
|
||||
List *regular = NIL,
|
||||
*i;
|
||||
List *instead_rules = NIL;
|
||||
List *regular = NIL,
|
||||
*i;
|
||||
List *instead_rules = NIL;
|
||||
|
||||
foreach(i, locks)
|
||||
{
|
||||
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
||||
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
||||
|
||||
if (rule_lock->isInstead)
|
||||
instead_rules = lappend(instead_rules, rule_lock);
|
||||
@ -154,11 +154,11 @@ orderRules(List * locks)
|
||||
static int
|
||||
AllRetrieve(List * actions)
|
||||
{
|
||||
List *n;
|
||||
List *n;
|
||||
|
||||
foreach(n, actions)
|
||||
{
|
||||
Query *pt = lfirst(n);
|
||||
Query *pt = lfirst(n);
|
||||
|
||||
/*
|
||||
* in the old postgres code, we check whether command_type is a
|
||||
@ -171,17 +171,17 @@ AllRetrieve(List * actions)
|
||||
return true;
|
||||
}
|
||||
|
||||
static List *
|
||||
static List *
|
||||
FireRetrieveRulesAtQuery(Query * parsetree,
|
||||
int rt_index,
|
||||
Relation relation,
|
||||
bool * instead_flag,
|
||||
int rule_flag)
|
||||
{
|
||||
List *i,
|
||||
*locks;
|
||||
RuleLock *rt_entry_locks = NULL;
|
||||
List *work = NIL;
|
||||
List *i,
|
||||
*locks;
|
||||
RuleLock *rt_entry_locks = NULL;
|
||||
List *work = NIL;
|
||||
|
||||
if ((rt_entry_locks = relation->rd_rules) == NULL)
|
||||
return NIL;
|
||||
@ -191,7 +191,7 @@ FireRetrieveRulesAtQuery(Query * parsetree,
|
||||
/* find all retrieve instead */
|
||||
foreach(i, locks)
|
||||
{
|
||||
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
||||
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
||||
|
||||
if (!rule_lock->isInstead)
|
||||
continue;
|
||||
@ -202,9 +202,9 @@ FireRetrieveRulesAtQuery(Query * parsetree,
|
||||
work = OptimizeRIRRules(locks);
|
||||
foreach(i, work)
|
||||
{
|
||||
RewriteRule *rule_lock = lfirst(i);
|
||||
int relation_level;
|
||||
int modified = FALSE;
|
||||
RewriteRule *rule_lock = lfirst(i);
|
||||
int relation_level;
|
||||
int modified = FALSE;
|
||||
|
||||
relation_level = (rule_lock->attrno == -1);
|
||||
if (rule_lock->actions == NIL)
|
||||
@ -248,13 +248,13 @@ ApplyRetrieveRule(Query * parsetree,
|
||||
int relation_level,
|
||||
int *modified)
|
||||
{
|
||||
Query *rule_action = NULL;
|
||||
Node *rule_qual;
|
||||
List *rtable,
|
||||
*rt;
|
||||
int nothing,
|
||||
rt_length;
|
||||
int badsql = FALSE;
|
||||
Query *rule_action = NULL;
|
||||
Node *rule_qual;
|
||||
List *rtable,
|
||||
*rt;
|
||||
int nothing,
|
||||
rt_length;
|
||||
int badsql = FALSE;
|
||||
|
||||
rule_qual = rule->qual;
|
||||
if (rule->actions)
|
||||
@ -274,7 +274,7 @@ ApplyRetrieveRule(Query * parsetree,
|
||||
rtable = copyObject(parsetree->rtable);
|
||||
foreach(rt, rtable)
|
||||
{
|
||||
RangeTblEntry *rte = lfirst(rt);
|
||||
RangeTblEntry *rte = lfirst(rt);
|
||||
|
||||
/*
|
||||
* this is to prevent add_missing_vars_to_base_rels() from adding
|
||||
@ -309,21 +309,21 @@ ApplyRetrieveRule(Query * parsetree,
|
||||
AddQual(parsetree, rule_action->qual);
|
||||
}
|
||||
|
||||
static List *
|
||||
static List *
|
||||
ProcessRetrieveQuery(Query * parsetree,
|
||||
List * rtable,
|
||||
bool * instead_flag,
|
||||
bool rule)
|
||||
{
|
||||
List *rt;
|
||||
List *product_queries = NIL;
|
||||
int rt_index = 0;
|
||||
List *rt;
|
||||
List *product_queries = NIL;
|
||||
int rt_index = 0;
|
||||
|
||||
foreach(rt, rtable)
|
||||
{
|
||||
RangeTblEntry *rt_entry = lfirst(rt);
|
||||
Relation rt_entry_relation = NULL;
|
||||
List *result = NIL;
|
||||
RangeTblEntry *rt_entry = lfirst(rt);
|
||||
Relation rt_entry_relation = NULL;
|
||||
List *result = NIL;
|
||||
|
||||
rt_index++;
|
||||
rt_entry_relation = heap_openr(rt_entry->relname);
|
||||
@ -346,12 +346,12 @@ ProcessRetrieveQuery(Query * parsetree,
|
||||
|
||||
foreach(rt, rtable)
|
||||
{
|
||||
RangeTblEntry *rt_entry = lfirst(rt);
|
||||
Relation rt_entry_relation = NULL;
|
||||
RuleLock *rt_entry_locks = NULL;
|
||||
List *result = NIL;
|
||||
List *locks = NIL;
|
||||
List *dummy_products;
|
||||
RangeTblEntry *rt_entry = lfirst(rt);
|
||||
Relation rt_entry_relation = NULL;
|
||||
RuleLock *rt_entry_locks = NULL;
|
||||
List *result = NIL;
|
||||
List *locks = NIL;
|
||||
List *dummy_products;
|
||||
|
||||
rt_index++;
|
||||
rt_entry_relation = heap_openr(rt_entry->relname);
|
||||
@ -376,16 +376,16 @@ ProcessRetrieveQuery(Query * parsetree,
|
||||
return product_queries;
|
||||
}
|
||||
|
||||
static Query *
|
||||
static Query *
|
||||
CopyAndAddQual(Query * parsetree,
|
||||
List * actions,
|
||||
Node * rule_qual,
|
||||
int rt_index,
|
||||
CmdType event)
|
||||
{
|
||||
Query *new_tree = (Query *) copyObject(parsetree);
|
||||
Node *new_qual = NULL;
|
||||
Query *rule_action = NULL;
|
||||
Query *new_tree = (Query *) copyObject(parsetree);
|
||||
Node *new_qual = NULL;
|
||||
Query *rule_action = NULL;
|
||||
|
||||
if (actions)
|
||||
rule_action = lfirst(actions);
|
||||
@ -393,8 +393,8 @@ CopyAndAddQual(Query * parsetree,
|
||||
new_qual = (Node *) copyObject(rule_qual);
|
||||
if (rule_action != NULL)
|
||||
{
|
||||
List *rtable;
|
||||
int rt_length;
|
||||
List *rtable;
|
||||
int rt_length;
|
||||
|
||||
rtable = new_tree->rtable;
|
||||
rt_length = length(rtable);
|
||||
@ -418,7 +418,7 @@ CopyAndAddQual(Query * parsetree,
|
||||
* sensible semantics. remember: reality is for dead birds -- glass
|
||||
*
|
||||
*/
|
||||
static List *
|
||||
static List *
|
||||
fireRules(Query * parsetree,
|
||||
int rt_index,
|
||||
CmdType event,
|
||||
@ -426,9 +426,9 @@ fireRules(Query * parsetree,
|
||||
List * locks,
|
||||
List ** qual_products)
|
||||
{
|
||||
RewriteInfo *info;
|
||||
List *results = NIL;
|
||||
List *i;
|
||||
RewriteInfo *info;
|
||||
List *results = NIL;
|
||||
List *i;
|
||||
|
||||
/* choose rule to fire from list of rules */
|
||||
if (locks == NIL)
|
||||
@ -445,12 +445,12 @@ fireRules(Query * parsetree,
|
||||
locks = orderRules(locks); /* instead rules first */
|
||||
foreach(i, locks)
|
||||
{
|
||||
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
||||
Node *qual,
|
||||
*event_qual;
|
||||
List *actions;
|
||||
List *r;
|
||||
bool orig_instead_flag = *instead_flag;
|
||||
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
||||
Node *qual,
|
||||
*event_qual;
|
||||
List *actions;
|
||||
List *r;
|
||||
bool orig_instead_flag = *instead_flag;
|
||||
|
||||
/* multiple rule action time */
|
||||
*instead_flag = rule_lock->isInstead;
|
||||
@ -463,8 +463,8 @@ fireRules(Query * parsetree,
|
||||
rt_index, event));
|
||||
foreach(r, actions)
|
||||
{
|
||||
Query *rule_action = lfirst(r);
|
||||
Node *rule_qual = copyObject(event_qual);
|
||||
Query *rule_action = lfirst(r);
|
||||
Node *rule_qual = copyObject(event_qual);
|
||||
|
||||
/*--------------------------------------------------
|
||||
* Step 1:
|
||||
@ -535,12 +535,12 @@ fireRules(Query * parsetree,
|
||||
return results;
|
||||
}
|
||||
|
||||
static List *
|
||||
static List *
|
||||
RewriteQuery(Query * parsetree, bool * instead_flag, List ** qual_products)
|
||||
{
|
||||
CmdType event;
|
||||
List *product_queries = NIL;
|
||||
int result_relation = 0;
|
||||
CmdType event;
|
||||
List *product_queries = NIL;
|
||||
int result_relation = 0;
|
||||
|
||||
Assert(parsetree != NULL);
|
||||
|
||||
@ -565,9 +565,9 @@ RewriteQuery(Query * parsetree, bool * instead_flag, List ** qual_products)
|
||||
/*
|
||||
* the statement is an update, insert or delete
|
||||
*/
|
||||
RangeTblEntry *rt_entry;
|
||||
Relation rt_entry_relation = NULL;
|
||||
RuleLock *rt_entry_locks = NULL;
|
||||
RangeTblEntry *rt_entry;
|
||||
Relation rt_entry_relation = NULL;
|
||||
RuleLock *rt_entry_locks = NULL;
|
||||
|
||||
rt_entry = rt_fetch(result_relation, parsetree->rtable);
|
||||
rt_entry_relation = heap_openr(rt_entry->relname);
|
||||
@ -576,7 +576,7 @@ RewriteQuery(Query * parsetree, bool * instead_flag, List ** qual_products)
|
||||
|
||||
if (rt_entry_locks != NULL)
|
||||
{
|
||||
List *locks =
|
||||
List *locks =
|
||||
matchLocks(event, rt_entry_locks, result_relation, parsetree);
|
||||
|
||||
product_queries =
|
||||
@ -595,7 +595,7 @@ RewriteQuery(Query * parsetree, bool * instead_flag, List ** qual_products)
|
||||
/*
|
||||
* the statement is a select
|
||||
*/
|
||||
Query *other;
|
||||
Query *other;
|
||||
|
||||
other = copyObject(parsetree); /* ApplyRetrieveRule changes the
|
||||
* range table */
|
||||
@ -613,14 +613,14 @@ RewriteQuery(Query * parsetree, bool * instead_flag, List ** qual_products)
|
||||
#define REWRITE_INVOKE_MAX 10
|
||||
#endif
|
||||
|
||||
static int numQueryRewriteInvoked = 0;
|
||||
static int numQueryRewriteInvoked = 0;
|
||||
|
||||
/*
|
||||
* QueryRewrite -
|
||||
* rewrite one query via QueryRewrite system, possibly returning 0, or many
|
||||
* queries
|
||||
*/
|
||||
List *
|
||||
List *
|
||||
QueryRewrite(Query * parsetree)
|
||||
{
|
||||
numQueryRewriteInvoked = 0;
|
||||
@ -635,14 +635,14 @@ QueryRewrite(Query * parsetree)
|
||||
* deepRewriteQuery -
|
||||
* rewrites the query and apply the rules again on the queries rewritten
|
||||
*/
|
||||
static List *
|
||||
static List *
|
||||
deepRewriteQuery(Query * parsetree)
|
||||
{
|
||||
List *n;
|
||||
List *rewritten = NIL;
|
||||
List *result = NIL;
|
||||
bool instead;
|
||||
List *qual_products = NIL;
|
||||
List *n;
|
||||
List *rewritten = NIL;
|
||||
List *result = NIL;
|
||||
bool instead;
|
||||
List *qual_products = NIL;
|
||||
|
||||
if (++numQueryRewriteInvoked > REWRITE_INVOKE_MAX)
|
||||
{
|
||||
@ -657,8 +657,8 @@ deepRewriteQuery(Query * parsetree)
|
||||
|
||||
foreach(n, result)
|
||||
{
|
||||
Query *pt = lfirst(n);
|
||||
List *newstuff = NIL;
|
||||
Query *pt = lfirst(n);
|
||||
List *newstuff = NIL;
|
||||
|
||||
newstuff = deepRewriteQuery(pt);
|
||||
if (newstuff != NIL)
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.5 1997/09/07 04:48:09 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.6 1997/09/08 02:28:18 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -28,7 +28,7 @@
|
||||
#include "nodes/plannodes.h"
|
||||
#include "optimizer/clauses.h"
|
||||
|
||||
static void ResolveNew(RewriteInfo * info, List * targetlist, Node ** node);
|
||||
static void ResolveNew(RewriteInfo * info, List * targetlist, Node ** node);
|
||||
|
||||
|
||||
|
||||
@ -39,41 +39,41 @@ OffsetVarNodes(Node * node, int offset)
|
||||
return;
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
OffsetVarNodes(tle->expr, offset);
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
OffsetVarNodes((Node *) expr->args, 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)
|
||||
case T_TargetEntry:
|
||||
{
|
||||
OffsetVarNodes(lfirst(l), offset);
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
OffsetVarNodes(tle->expr, offset);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
OffsetVarNodes((Node *) expr->args, 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;
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -84,52 +84,52 @@ ChangeVarNodes(Node * node, int old_varno, int new_varno)
|
||||
return;
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
ChangeVarNodes(tle->expr, old_varno, new_varno);
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
ChangeVarNodes((Node *) expr->args, old_varno, new_varno);
|
||||
}
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *) node;
|
||||
|
||||
if (var->varno == old_varno)
|
||||
case T_TargetEntry:
|
||||
{
|
||||
var->varno = new_varno;
|
||||
var->varnoold = new_varno;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
{
|
||||
ChangeVarNodes(lfirst(l), old_varno, new_varno);
|
||||
ChangeVarNodes(tle->expr, old_varno, new_varno);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
ChangeVarNodes((Node *) expr->args, old_varno, new_varno);
|
||||
}
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *) node;
|
||||
|
||||
if (var->varno == old_varno)
|
||||
{
|
||||
var->varno = new_varno;
|
||||
var->varnoold = new_varno;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
{
|
||||
ChangeVarNodes(lfirst(l), old_varno, new_varno);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
AddQual(Query * parsetree, Node * qual)
|
||||
{
|
||||
Node *copy,
|
||||
*old;
|
||||
Node *copy,
|
||||
*old;
|
||||
|
||||
if (qual == NULL)
|
||||
return;
|
||||
@ -146,7 +146,7 @@ AddQual(Query * parsetree, Node * qual)
|
||||
void
|
||||
AddNotQual(Query * parsetree, Node * qual)
|
||||
{
|
||||
Node *copy;
|
||||
Node *copy;
|
||||
|
||||
if (qual == NULL)
|
||||
return;
|
||||
@ -156,10 +156,10 @@ AddNotQual(Query * parsetree, Node * qual)
|
||||
AddQual(parsetree, copy);
|
||||
}
|
||||
|
||||
static Node *
|
||||
static Node *
|
||||
make_null(Oid type)
|
||||
{
|
||||
Const *c = makeNode(Const);
|
||||
Const *c = makeNode(Const);
|
||||
|
||||
c->consttype = type;
|
||||
c->constlen = get_typlen(type);
|
||||
@ -172,15 +172,15 @@ make_null(Oid type)
|
||||
void
|
||||
FixResdomTypes(List * tlist)
|
||||
{
|
||||
List *i;
|
||||
List *i;
|
||||
|
||||
foreach(i, tlist)
|
||||
{
|
||||
TargetEntry *tle = lfirst(i);
|
||||
TargetEntry *tle = lfirst(i);
|
||||
|
||||
if (nodeTag(tle->expr) == T_Var)
|
||||
{
|
||||
Var *var = (Var *) tle->expr;
|
||||
Var *var = (Var *) tle->expr;
|
||||
|
||||
tle->resdom->restype = var->vartype;
|
||||
tle->resdom->reslen = get_typlen(var->vartype);
|
||||
@ -188,14 +188,14 @@ FixResdomTypes(List * tlist)
|
||||
}
|
||||
}
|
||||
|
||||
static Node *
|
||||
static Node *
|
||||
FindMatchingNew(List * tlist, int attno)
|
||||
{
|
||||
List *i;
|
||||
List *i;
|
||||
|
||||
foreach(i, tlist)
|
||||
{
|
||||
TargetEntry *tle = lfirst(i);
|
||||
TargetEntry *tle = lfirst(i);
|
||||
|
||||
if (tle->resdom->resno == attno)
|
||||
{
|
||||
@ -205,15 +205,15 @@ FindMatchingNew(List * tlist, int attno)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static Node *
|
||||
static Node *
|
||||
FindMatchingTLEntry(List * tlist, char *e_attname)
|
||||
{
|
||||
List *i;
|
||||
List *i;
|
||||
|
||||
foreach(i, tlist)
|
||||
{
|
||||
TargetEntry *tle = lfirst(i);
|
||||
char *resname;
|
||||
TargetEntry *tle = lfirst(i);
|
||||
char *resname;
|
||||
|
||||
resname = tle->resdom->resname;
|
||||
if (!strcmp(e_attname, resname))
|
||||
@ -225,60 +225,60 @@ FindMatchingTLEntry(List * tlist, char *e_attname)
|
||||
static void
|
||||
ResolveNew(RewriteInfo * info, List * targetlist, Node ** nodePtr)
|
||||
{
|
||||
Node *node = *nodePtr;
|
||||
Node *node = *nodePtr;
|
||||
|
||||
if (node == NULL)
|
||||
return;
|
||||
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
case T_TargetEntry:
|
||||
ResolveNew(info, targetlist, &((TargetEntry *) node)->expr);
|
||||
break;
|
||||
case T_Expr:
|
||||
ResolveNew(info, targetlist, (Node **) (&(((Expr *) node)->args)));
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
int this_varno = (int) ((Var *) node)->varno;
|
||||
Node *n;
|
||||
|
||||
if (this_varno == info->new_varno)
|
||||
case T_TargetEntry:
|
||||
ResolveNew(info, targetlist, &((TargetEntry *) node)->expr);
|
||||
break;
|
||||
case T_Expr:
|
||||
ResolveNew(info, targetlist, (Node **) (&(((Expr *) node)->args)));
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
n = FindMatchingNew(targetlist,
|
||||
((Var *) node)->varattno);
|
||||
if (n == NULL)
|
||||
int this_varno = (int) ((Var *) node)->varno;
|
||||
Node *n;
|
||||
|
||||
if (this_varno == info->new_varno)
|
||||
{
|
||||
if (info->event == CMD_UPDATE)
|
||||
n = FindMatchingNew(targetlist,
|
||||
((Var *) node)->varattno);
|
||||
if (n == NULL)
|
||||
{
|
||||
((Var *) node)->varno = info->current_varno;
|
||||
((Var *) node)->varnoold = info->current_varno;
|
||||
if (info->event == CMD_UPDATE)
|
||||
{
|
||||
((Var *) node)->varno = info->current_varno;
|
||||
((Var *) node)->varnoold = info->current_varno;
|
||||
}
|
||||
else
|
||||
{
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
*nodePtr = n;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*nodePtr = n;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
case T_List:
|
||||
{
|
||||
ResolveNew(info, targetlist, (Node **) & (lfirst(l)));
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
{
|
||||
ResolveNew(info, targetlist, (Node **) & (lfirst(l)));
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
}
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -299,86 +299,86 @@ nodeHandleRIRAttributeRule(Node ** nodePtr,
|
||||
int *modified,
|
||||
int *badsql)
|
||||
{
|
||||
Node *node = *nodePtr;
|
||||
Node *node = *nodePtr;
|
||||
|
||||
if (node == NULL)
|
||||
return;
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
case T_List:
|
||||
{
|
||||
List *i;
|
||||
|
||||
foreach(i, (List *) node)
|
||||
case T_List:
|
||||
{
|
||||
nodeHandleRIRAttributeRule((Node **) (&(lfirst(i))), rtable,
|
||||
List *i;
|
||||
|
||||
foreach(i, (List *) node)
|
||||
{
|
||||
nodeHandleRIRAttributeRule((Node **) (&(lfirst(i))), rtable,
|
||||
targetlist, rt_index, attr_num,
|
||||
modified, badsql);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
nodeHandleRIRAttributeRule(&tle->expr, rtable, targetlist,
|
||||
rt_index, attr_num, modified, badsql);
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
nodeHandleRIRAttributeRule((Node **) (&(expr->args)), rtable,
|
||||
targetlist, rt_index, attr_num,
|
||||
modified, badsql);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
nodeHandleRIRAttributeRule(&tle->expr, rtable, targetlist,
|
||||
rt_index, attr_num, modified, badsql);
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
nodeHandleRIRAttributeRule((Node **) (&(expr->args)), rtable,
|
||||
targetlist, rt_index, attr_num,
|
||||
modified, badsql);
|
||||
}
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
int this_varno = (int) ((Var *) node)->varno;
|
||||
NameData name_to_look_for;
|
||||
|
||||
memset(name_to_look_for.data, 0, NAMEDATALEN);
|
||||
|
||||
if (this_varno == rt_index &&
|
||||
((Var *) node)->varattno == attr_num)
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
if (((Var *) node)->vartype == 32)
|
||||
{ /* HACK */
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
int this_varno = (int) ((Var *) node)->varno;
|
||||
NameData name_to_look_for;
|
||||
|
||||
memset(name_to_look_for.data, 0, NAMEDATALEN);
|
||||
|
||||
if (this_varno == rt_index &&
|
||||
((Var *) node)->varattno == attr_num)
|
||||
{
|
||||
if (((Var *) node)->vartype == 32)
|
||||
{ /* HACK */
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
*modified = TRUE;
|
||||
*badsql = TRUE;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
namestrcpy(&name_to_look_for,
|
||||
(char *) get_attname(getrelid(this_varno,
|
||||
rtable),
|
||||
attr_num));
|
||||
}
|
||||
}
|
||||
if (name_to_look_for.data[0])
|
||||
{
|
||||
Node *n;
|
||||
|
||||
n = FindMatchingTLEntry(targetlist, (char *) &name_to_look_for);
|
||||
if (n == NULL)
|
||||
{
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
}
|
||||
else
|
||||
{
|
||||
*nodePtr = n;
|
||||
}
|
||||
*modified = TRUE;
|
||||
*badsql = TRUE;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
namestrcpy(&name_to_look_for,
|
||||
(char *) get_attname(getrelid(this_varno,
|
||||
rtable),
|
||||
attr_num));
|
||||
}
|
||||
}
|
||||
if (name_to_look_for.data[0])
|
||||
{
|
||||
Node *n;
|
||||
|
||||
n = FindMatchingTLEntry(targetlist, (char *) &name_to_look_for);
|
||||
if (n == NULL)
|
||||
{
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
}
|
||||
else
|
||||
{
|
||||
*nodePtr = n;
|
||||
}
|
||||
*modified = TRUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
break;
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -410,69 +410,69 @@ nodeHandleViewRule(Node ** nodePtr,
|
||||
int rt_index,
|
||||
int *modified)
|
||||
{
|
||||
Node *node = *nodePtr;
|
||||
Node *node = *nodePtr;
|
||||
|
||||
if (node == NULL)
|
||||
return;
|
||||
|
||||
switch (nodeTag(node))
|
||||
{
|
||||
case T_List:
|
||||
{
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
case T_List:
|
||||
{
|
||||
nodeHandleViewRule((Node **) (&(lfirst(l))),
|
||||
List *l;
|
||||
|
||||
foreach(l, (List *) node)
|
||||
{
|
||||
nodeHandleViewRule((Node **) (&(lfirst(l))),
|
||||
rtable, targetlist,
|
||||
rt_index, modified);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
nodeHandleViewRule(&(tle->expr), rtable, targetlist,
|
||||
rt_index, modified);
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
nodeHandleViewRule((Node **) (&(expr->args)),
|
||||
rtable, targetlist,
|
||||
rt_index, modified);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case T_TargetEntry:
|
||||
{
|
||||
TargetEntry *tle = (TargetEntry *) node;
|
||||
|
||||
nodeHandleViewRule(&(tle->expr), rtable, targetlist,
|
||||
rt_index, modified);
|
||||
}
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
Expr *expr = (Expr *) node;
|
||||
|
||||
nodeHandleViewRule((Node **) (&(expr->args)),
|
||||
rtable, targetlist,
|
||||
rt_index, modified);
|
||||
}
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *) node;
|
||||
int this_varno = var->varno;
|
||||
Node *n;
|
||||
|
||||
if (this_varno == rt_index)
|
||||
{
|
||||
n = FindMatchingTLEntry(targetlist,
|
||||
get_attname(getrelid(this_varno,
|
||||
rtable),
|
||||
var->varattno));
|
||||
if (n == NULL)
|
||||
{
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
}
|
||||
else
|
||||
{
|
||||
*nodePtr = n;
|
||||
}
|
||||
*modified = TRUE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
case T_Var:
|
||||
{
|
||||
Var *var = (Var *) node;
|
||||
int this_varno = var->varno;
|
||||
Node *n;
|
||||
|
||||
if (this_varno == rt_index)
|
||||
{
|
||||
n = FindMatchingTLEntry(targetlist,
|
||||
get_attname(getrelid(this_varno,
|
||||
rtable),
|
||||
var->varattno));
|
||||
if (n == NULL)
|
||||
{
|
||||
*nodePtr = make_null(((Var *) node)->vartype);
|
||||
}
|
||||
else
|
||||
{
|
||||
*nodePtr = n;
|
||||
}
|
||||
*modified = TRUE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
/* ignore the others */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.3 1997/09/07 04:48:10 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.4 1997/09/08 02:28:20 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -31,11 +31,11 @@
|
||||
* RewriteGetRuleEventRel
|
||||
*-----------------------------------------------------------------------
|
||||
*/
|
||||
char *
|
||||
char *
|
||||
RewriteGetRuleEventRel(char *rulename)
|
||||
{
|
||||
HeapTuple htp;
|
||||
Oid eventrel;
|
||||
HeapTuple htp;
|
||||
Oid eventrel;
|
||||
|
||||
htp = SearchSysCacheTuple(REWRITENAME, PointerGetDatum(rulename),
|
||||
0, 0, 0);
|
||||
@ -69,15 +69,15 @@ RewriteGetRuleEventRel(char *rulename)
|
||||
void
|
||||
RemoveRewriteRule(char *ruleName)
|
||||
{
|
||||
Relation RewriteRelation = NULL;
|
||||
HeapScanDesc scanDesc = NULL;
|
||||
ScanKeyData scanKeyData;
|
||||
HeapTuple tuple = NULL;
|
||||
Oid ruleId = (Oid) 0;
|
||||
Oid eventRelationOid = (Oid) NULL;
|
||||
Datum eventRelationOidDatum = (Datum) NULL;
|
||||
Buffer buffer = (Buffer) NULL;
|
||||
bool isNull = false;
|
||||
Relation RewriteRelation = NULL;
|
||||
HeapScanDesc scanDesc = NULL;
|
||||
ScanKeyData scanKeyData;
|
||||
HeapTuple tuple = NULL;
|
||||
Oid ruleId = (Oid) 0;
|
||||
Oid eventRelationOid = (Oid) NULL;
|
||||
Datum eventRelationOidDatum = (Datum) NULL;
|
||||
Buffer buffer = (Buffer) NULL;
|
||||
bool isNull = false;
|
||||
|
||||
/*
|
||||
* Open the pg_rewrite relation.
|
||||
@ -145,10 +145,10 @@ RemoveRewriteRule(char *ruleName)
|
||||
void
|
||||
RelationRemoveRules(Oid relid)
|
||||
{
|
||||
Relation RewriteRelation = NULL;
|
||||
HeapScanDesc scanDesc = NULL;
|
||||
ScanKeyData scanKeyData;
|
||||
HeapTuple tuple = NULL;
|
||||
Relation RewriteRelation = NULL;
|
||||
HeapScanDesc scanDesc = NULL;
|
||||
ScanKeyData scanKeyData;
|
||||
HeapTuple tuple = NULL;
|
||||
|
||||
/*
|
||||
* Open the pg_rewrite relation.
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.7 1997/09/07 04:48:11 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.8 1997/09/08 02:28:20 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -37,18 +37,18 @@
|
||||
* list of parsetrees for the rule (in parseTrees)
|
||||
*/
|
||||
#ifdef NOT_USED
|
||||
static Node *
|
||||
static Node *
|
||||
RuleIdGetActionInfo(Oid ruleoid, bool * instead_flag, Query ** parseTrees)
|
||||
{
|
||||
HeapTuple ruletuple;
|
||||
char *ruleaction = NULL;
|
||||
bool action_is_null = false;
|
||||
bool instead_is_null = false;
|
||||
Relation ruleRelation = NULL;
|
||||
TupleDesc ruleTupdesc = NULL;
|
||||
Query *ruleparse = NULL;
|
||||
char *rule_evqual_string = NULL;
|
||||
Node *rule_evqual = NULL;
|
||||
HeapTuple ruletuple;
|
||||
char *ruleaction = NULL;
|
||||
bool action_is_null = false;
|
||||
bool instead_is_null = false;
|
||||
Relation ruleRelation = NULL;
|
||||
TupleDesc ruleTupdesc = NULL;
|
||||
Query *ruleparse = NULL;
|
||||
char *rule_evqual_string = NULL;
|
||||
Node *rule_evqual = NULL;
|
||||
|
||||
ruleRelation = heap_openr(RewriteRelationName);
|
||||
ruleTupdesc = RelationGetTupleDescriptor(ruleRelation);
|
||||
@ -92,10 +92,10 @@ RuleIdGetActionInfo(Oid ruleoid, bool * instead_flag, Query ** parseTrees)
|
||||
int
|
||||
IsDefinedRewriteRule(char *ruleName)
|
||||
{
|
||||
Relation RewriteRelation = NULL;
|
||||
HeapScanDesc scanDesc = NULL;
|
||||
ScanKeyData scanKey;
|
||||
HeapTuple tuple = NULL;
|
||||
Relation RewriteRelation = NULL;
|
||||
HeapScanDesc scanDesc = NULL;
|
||||
ScanKeyData scanKey;
|
||||
HeapTuple tuple = NULL;
|
||||
|
||||
|
||||
/*
|
||||
@ -124,11 +124,11 @@ IsDefinedRewriteRule(char *ruleName)
|
||||
static void
|
||||
setRelhasrulesInRelation(Oid relationId, bool relhasrules)
|
||||
{
|
||||
Relation relationRelation;
|
||||
HeapTuple tuple;
|
||||
HeapTuple newTuple;
|
||||
Relation idescs[Num_pg_class_indices];
|
||||
Form_pg_class relp;
|
||||
Relation relationRelation;
|
||||
HeapTuple tuple;
|
||||
HeapTuple newTuple;
|
||||
Relation idescs[Num_pg_class_indices];
|
||||
Form_pg_class relp;
|
||||
|
||||
/*
|
||||
* Lock a relation given its Oid. Go to the RelationRelation (i.e.
|
||||
@ -172,10 +172,10 @@ prs2_addToRelation(Oid relid,
|
||||
Node * qual,
|
||||
List * actions)
|
||||
{
|
||||
Relation relation;
|
||||
RewriteRule *thisRule;
|
||||
RuleLock *rulelock;
|
||||
MemoryContext oldcxt;
|
||||
Relation relation;
|
||||
RewriteRule *thisRule;
|
||||
RuleLock *rulelock;
|
||||
MemoryContext oldcxt;
|
||||
|
||||
/*
|
||||
* create an in memory RewriteRule data structure which is cached by
|
||||
@ -217,7 +217,7 @@ prs2_addToRelation(Oid relid,
|
||||
}
|
||||
else
|
||||
{
|
||||
int numlock;
|
||||
int numlock;
|
||||
|
||||
rulelock = relation->rd_rules;
|
||||
numlock = rulelock->numLocks;
|
||||
@ -239,11 +239,11 @@ prs2_addToRelation(Oid relid,
|
||||
void
|
||||
prs2_deleteFromRelation(Oid relid, Oid ruleId)
|
||||
{
|
||||
RuleLock *rulelock;
|
||||
Relation relation;
|
||||
int numlock;
|
||||
int i;
|
||||
MemoryContext oldcxt;
|
||||
RuleLock *rulelock;
|
||||
Relation relation;
|
||||
int numlock;
|
||||
int i;
|
||||
MemoryContext oldcxt;
|
||||
|
||||
relation = heap_open(relid);
|
||||
rulelock = relation->rd_rules;
|
||||
|
||||
Reference in New Issue
Block a user