1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* rewriteHandler.c--
|
|
|
|
*
|
|
|
|
* Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
1998-10-21 18:21:29 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.25 1998/10/21 16:21:24 momjian Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1998-02-21 07:32:15 +01:00
|
|
|
#include <string.h>
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "postgres.h"
|
|
|
|
#include "miscadmin.h"
|
|
|
|
#include "utils/palloc.h"
|
|
|
|
#include "utils/elog.h"
|
|
|
|
#include "utils/rel.h"
|
1997-09-07 07:04:48 +02:00
|
|
|
#include "nodes/pg_list.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "nodes/primnodes.h"
|
1998-10-02 18:28:04 +02:00
|
|
|
#include "nodes/relation.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
#include "parser/parsetree.h" /* for parsetree manipulation */
|
1998-08-18 02:49:04 +02:00
|
|
|
#include "parser/parse_relation.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "nodes/parsenodes.h"
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
#include "rewrite/rewriteSupport.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "rewrite/rewriteHandler.h"
|
|
|
|
#include "rewrite/rewriteManip.h"
|
|
|
|
#include "rewrite/locks.h"
|
|
|
|
|
|
|
|
#include "commands/creatinh.h"
|
|
|
|
#include "access/heapam.h"
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
#include "utils/lsyscache.h"
|
1998-02-21 07:32:15 +01:00
|
|
|
#include "utils/syscache.h"
|
|
|
|
#include "utils/acl.h"
|
1998-02-25 14:09:49 +01:00
|
|
|
#include "catalog/pg_shadow.h"
|
1998-10-02 18:28:04 +02:00
|
|
|
#include "catalog/pg_type.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static RewriteInfo *gatherRewriteMeta(Query *parsetree,
|
|
|
|
Query *rule_action,
|
|
|
|
Node *rule_qual,
|
|
|
|
int rt_index,
|
|
|
|
CmdType event,
|
|
|
|
bool *instead_flag);
|
|
|
|
static bool rangeTableEntry_used(Node *node, int rt_index, int sublevels_up);
|
|
|
|
static bool attribute_used(Node *node, int rt_index, int attno, int sublevels_up);
|
|
|
|
static void modifyAggregUplevel(Node *node);
|
|
|
|
static void modifyAggregChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up);
|
|
|
|
static void modifyAggregDropQual(Node **nodePtr, Node *orignode, Expr *expr);
|
|
|
|
static SubLink *modifyAggregMakeSublink(Expr *origexp, Query *parsetree);
|
|
|
|
static void modifyAggregQual(Node **nodePtr, Query *parsetree);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static Query *fireRIRrules(Query *parsetree);
|
1998-02-21 07:32:15 +01:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* gatherRewriteMeta -
|
1997-09-07 07:04:48 +02:00
|
|
|
* Gather meta information about parsetree, and rule. Fix rule body
|
|
|
|
* and qualifier so that they can be mixed with the parsetree and
|
|
|
|
* maintain semantic validity
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
static RewriteInfo *
|
1997-09-08 23:56:23 +02:00
|
|
|
gatherRewriteMeta(Query *parsetree,
|
|
|
|
Query *rule_action,
|
|
|
|
Node *rule_qual,
|
1997-09-07 07:04:48 +02:00
|
|
|
int rt_index,
|
|
|
|
CmdType event,
|
1997-09-08 23:56:23 +02:00
|
|
|
bool *instead_flag)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RewriteInfo *info;
|
|
|
|
int rt_length;
|
|
|
|
int result_reln;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
info = (RewriteInfo *) palloc(sizeof(RewriteInfo));
|
|
|
|
info->rt_index = rt_index;
|
|
|
|
info->event = event;
|
|
|
|
info->instead_flag = *instead_flag;
|
|
|
|
info->rule_action = (Query *) copyObject(rule_action);
|
|
|
|
info->rule_qual = (Node *) copyObject(rule_qual);
|
|
|
|
if (info->rule_action == NULL)
|
|
|
|
info->nothing = TRUE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
info->nothing = FALSE;
|
|
|
|
info->action = info->rule_action->commandType;
|
|
|
|
info->current_varno = rt_index;
|
|
|
|
info->rt = parsetree->rtable;
|
|
|
|
rt_length = length(info->rt);
|
|
|
|
info->rt = append(info->rt, info->rule_action->rtable);
|
|
|
|
|
|
|
|
info->new_varno = PRS2_NEW_VARNO + rt_length;
|
1998-10-21 18:21:29 +02:00
|
|
|
OffsetVarNodes(info->rule_action->qual, rt_length, 0);
|
|
|
|
OffsetVarNodes((Node *) info->rule_action->targetList, rt_length, 0);
|
|
|
|
OffsetVarNodes(info->rule_qual, rt_length, 0);
|
1997-09-07 07:04:48 +02:00
|
|
|
ChangeVarNodes((Node *) info->rule_action->qual,
|
1998-01-21 05:24:46 +01:00
|
|
|
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
1997-09-07 07:04:48 +02:00
|
|
|
ChangeVarNodes((Node *) info->rule_action->targetList,
|
1998-01-21 05:24:46 +01:00
|
|
|
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
1997-09-07 07:04:48 +02:00
|
|
|
ChangeVarNodes(info->rule_qual,
|
1998-01-21 05:24:46 +01:00
|
|
|
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* bug here about replace CURRENT -- sort of replace current is
|
|
|
|
* deprecated now so this code shouldn't really need to be so
|
|
|
|
* clutzy but.....
|
|
|
|
*/
|
|
|
|
if (info->action != CMD_SELECT)
|
|
|
|
{ /* i.e update XXXXX */
|
1997-09-08 04:41:22 +02:00
|
|
|
int new_result_reln = 0;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
result_reln = info->rule_action->resultRelation;
|
|
|
|
switch (result_reln)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
case PRS2_CURRENT_VARNO:
|
|
|
|
new_result_reln = rt_index;
|
|
|
|
break;
|
|
|
|
case PRS2_NEW_VARNO: /* XXX */
|
|
|
|
default:
|
|
|
|
new_result_reln = result_reln + rt_length;
|
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
info->rule_action->resultRelation = new_result_reln;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return info;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1998-10-02 18:28:04 +02:00
|
|
|
* rangeTableEntry_used -
|
|
|
|
* we need to process a RTE for RIR rules only if it is
|
|
|
|
* referenced somewhere in var nodes of the query.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1998-10-02 18:28:04 +02:00
|
|
|
static bool
|
|
|
|
rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1998-10-02 18:28:04 +02:00
|
|
|
if (node == NULL)
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *)node;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return rangeTableEntry_used(
|
|
|
|
(Node *)(tle->expr),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return rangeTableEntry_used(
|
|
|
|
(Node *)(agg->target),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_GroupClause:
|
|
|
|
{
|
|
|
|
GroupClause *grp = (GroupClause *)node;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return rangeTableEntry_used(
|
|
|
|
(Node *)(grp->entry),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
|
|
|
|
|
|
|
return rangeTableEntry_used(
|
|
|
|
(Node *)(exp->args),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return rangeTableEntry_used(
|
|
|
|
(Node *)(iter->iterexpr),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(ref->refupperindexpr),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(ref->reflowerindexpr),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(ref->refexpr),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(ref->refassgnexpr),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Var:
|
|
|
|
{
|
|
|
|
Var *var = (Var *)node;
|
|
|
|
|
|
|
|
if (var->varlevelsup == sublevels_up)
|
|
|
|
return var->varno == rt_index;
|
|
|
|
else
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Const:
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
case T_List:
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1998-10-02 18:28:04 +02:00
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node) {
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)lfirst(l),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1998-10-02 18:28:04 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1998-10-02 18:28:04 +02:00
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(sub->lefthand),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(sub->subselect),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up + 1))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1998-10-02 18:28:04 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1998-10-02 18:28:04 +02:00
|
|
|
Query *qry = (Query *)node;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(qry->targetList),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(qry->qual),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(qry->havingQual),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (rangeTableEntry_used(
|
|
|
|
(Node *)(qry->groupClause),
|
|
|
|
rt_index,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1998-10-02 18:28:04 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in rangeTableEntry_used()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1998-10-02 18:28:04 +02:00
|
|
|
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
/*
|
|
|
|
* attribute_used -
|
|
|
|
* Check if a specific attribute number of a RTE is used
|
|
|
|
* somewhere in the query
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1998-10-02 18:28:04 +02:00
|
|
|
static bool
|
|
|
|
attribute_used(Node *node, int rt_index, int attno, int sublevels_up)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1998-10-02 18:28:04 +02:00
|
|
|
if (node == NULL)
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *)node;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return attribute_used(
|
|
|
|
(Node *)(tle->expr),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return attribute_used(
|
|
|
|
(Node *)(agg->target),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1998-02-21 07:32:15 +01:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_GroupClause:
|
|
|
|
{
|
|
|
|
GroupClause *grp = (GroupClause *)node;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return attribute_used(
|
|
|
|
(Node *)(grp->entry),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1998-09-01 06:40:42 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
1998-07-19 07:49:26 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return attribute_used(
|
|
|
|
(Node *)(exp->args),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1998-07-19 07:49:26 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
1998-07-19 07:49:26 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return attribute_used(
|
|
|
|
(Node *)(iter->iterexpr),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
1998-09-01 06:40:42 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(ref->refupperindexpr),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(ref->reflowerindexpr),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(ref->refexpr),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(ref->refassgnexpr),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
break;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Var:
|
|
|
|
{
|
|
|
|
Var *var = (Var *)node;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
if (var->varlevelsup == sublevels_up)
|
|
|
|
return var->varno == rt_index;
|
|
|
|
else
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
break;
|
1998-03-30 18:36:43 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Param:
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_Const:
|
|
|
|
return FALSE;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node) {
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)lfirst(l),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(sub->lefthand),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(sub->subselect),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up + 1))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
|
|
|
{
|
|
|
|
Query *qry = (Query *)node;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(qry->targetList),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(qry->qual),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(qry->havingQual),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
if (attribute_used(
|
|
|
|
(Node *)(qry->groupClause),
|
|
|
|
rt_index,
|
|
|
|
attno,
|
|
|
|
sublevels_up))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in attribute_used()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
1998-03-30 18:36:43 +02:00
|
|
|
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return FALSE;
|
|
|
|
}
|
1998-08-24 03:38:11 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
/*
|
|
|
|
* modifyAggregUplevel -
|
|
|
|
* In the newly created sublink for an aggregate column used in
|
|
|
|
* the qualification, we must adjust the varlevelsup in all the
|
|
|
|
* var nodes.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
modifyAggregUplevel(Node *node)
|
|
|
|
{
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *)node;
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(tle->expr));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(agg->target));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(exp->args));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(iter->iterexpr));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(ref->refupperindexpr));
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(ref->reflowerindexpr));
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(ref->refexpr));
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(ref->refassgnexpr));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Var:
|
|
|
|
{
|
|
|
|
Var *var = (Var *)node;
|
|
|
|
|
|
|
|
var->varlevelsup++;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Const:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node)
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)lfirst(l));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(sub->lefthand));
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(sub->oper));
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(sub->subselect));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
|
|
|
{
|
|
|
|
Query *qry = (Query *)node;
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(qry->targetList));
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(qry->qual));
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(qry->havingQual));
|
|
|
|
|
|
|
|
modifyAggregUplevel(
|
|
|
|
(Node *)(qry->groupClause));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in modifyAggregUplevel()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* modifyAggregChangeVarnodes -
|
|
|
|
* Change the var nodes in a sublink created for an aggregate column
|
|
|
|
* used in the qualification that is subject of the aggregate
|
|
|
|
* function to point to the correct local RTE.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
modifyAggregChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up)
|
|
|
|
{
|
|
|
|
Node *node = *nodePtr;
|
|
|
|
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(tle->expr)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(agg->target)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_GroupClause:
|
|
|
|
{
|
|
|
|
GroupClause *grp = (GroupClause *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(grp->entry)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(exp->args)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(iter->iterexpr)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(ref->refupperindexpr)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(ref->reflowerindexpr)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(ref->refexpr)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(ref->refassgnexpr)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Var:
|
|
|
|
{
|
|
|
|
Var *var = (Var *)node;
|
|
|
|
|
|
|
|
if (var->varlevelsup == sublevels_up &&
|
|
|
|
var->varno == rt_index) {
|
|
|
|
var = copyObject(var);
|
|
|
|
var->varno = new_index;
|
|
|
|
var->varnoold = new_index;
|
|
|
|
var->varlevelsup = 0;
|
|
|
|
|
|
|
|
*nodePtr = (Node *)var;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Const:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node)
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&lfirst(l)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(sub->lefthand)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(sub->oper)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(sub->subselect)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up + 1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
|
|
|
{
|
|
|
|
Query *qry = (Query *)node;
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(qry->targetList)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(qry->qual)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(qry->havingQual)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes(
|
|
|
|
(Node **)(&(qry->groupClause)),
|
|
|
|
rt_index,
|
|
|
|
new_index,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in modifyAggregChangeVarnodes()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* modifyAggregDropQual -
|
|
|
|
* remove the pure aggreg clase from a qualification
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
modifyAggregDropQual(Node **nodePtr, Node *orignode, Expr *expr)
|
|
|
|
{
|
|
|
|
Node *node = *nodePtr;
|
|
|
|
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_Var:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
|
|
|
Aggreg *oagg = (Aggreg *)orignode;
|
|
|
|
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(agg->target)),
|
|
|
|
(Node *)(oagg->target),
|
|
|
|
expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Const:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_GroupClause:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *this_expr = (Expr *)node;
|
|
|
|
Expr *orig_expr = (Expr *)orignode;
|
|
|
|
|
|
|
|
if (orig_expr == expr) {
|
|
|
|
Const *ctrue;
|
|
|
|
|
|
|
|
if (expr->typeOid != BOOLOID)
|
|
|
|
elog(ERROR,
|
|
|
|
"aggregate expression in qualification isn't of type bool");
|
|
|
|
ctrue = makeNode(Const);
|
|
|
|
ctrue->consttype = BOOLOID;
|
|
|
|
ctrue->constlen = 1;
|
|
|
|
ctrue->constisnull = FALSE;
|
|
|
|
ctrue->constvalue = (Datum)TRUE;
|
|
|
|
ctrue->constbyval = TRUE;
|
|
|
|
|
|
|
|
*nodePtr = (Node *)ctrue;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(this_expr->args)),
|
|
|
|
(Node *)(orig_expr->args),
|
|
|
|
expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
|
|
|
Iter *oiter = (Iter *)orignode;
|
|
|
|
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(iter->iterexpr)),
|
|
|
|
(Node *)(oiter->iterexpr),
|
|
|
|
expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
ArrayRef *oref = (ArrayRef *)orignode;
|
|
|
|
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(ref->refupperindexpr)),
|
|
|
|
(Node *)(oref->refupperindexpr),
|
|
|
|
expr);
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(ref->reflowerindexpr)),
|
|
|
|
(Node *)(oref->reflowerindexpr),
|
|
|
|
expr);
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(ref->refexpr)),
|
|
|
|
(Node *)(oref->refexpr),
|
|
|
|
expr);
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(ref->refassgnexpr)),
|
|
|
|
(Node *)(oref->refassgnexpr),
|
|
|
|
expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
List *ol = (List *)orignode;
|
|
|
|
int li = 0;
|
|
|
|
|
|
|
|
foreach (l, (List *)node) {
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(lfirst(l))),
|
|
|
|
(Node *)nth(li, ol),
|
|
|
|
expr);
|
|
|
|
li++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
SubLink *osub = (SubLink *)orignode;
|
|
|
|
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(sub->subselect)),
|
|
|
|
(Node *)(osub->subselect),
|
|
|
|
expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
|
|
|
{
|
|
|
|
Query *qry = (Query *)node;
|
|
|
|
Query *oqry = (Query *)orignode;
|
|
|
|
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(qry->qual)),
|
|
|
|
(Node *)(oqry->qual),
|
|
|
|
expr);
|
|
|
|
|
|
|
|
modifyAggregDropQual(
|
|
|
|
(Node **)(&(qry->havingQual)),
|
|
|
|
(Node *)(oqry->havingQual),
|
|
|
|
expr);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in modifyAggregDropQual()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* modifyAggregMakeSublink -
|
|
|
|
* Create a sublink node for a qualification expression that
|
|
|
|
* uses an aggregate column of a view
|
|
|
|
*/
|
|
|
|
static SubLink *
|
|
|
|
modifyAggregMakeSublink(Expr *origexp, Query *parsetree)
|
|
|
|
{
|
|
|
|
SubLink *sublink;
|
|
|
|
Query *subquery;
|
|
|
|
Node *subqual;
|
|
|
|
RangeTblEntry *rte;
|
|
|
|
Aggreg *aggreg;
|
|
|
|
Var *target;
|
|
|
|
TargetEntry *tle;
|
|
|
|
Resdom *resdom;
|
|
|
|
Expr *exp = copyObject(origexp);
|
|
|
|
|
|
|
|
if (nodeTag(nth(0, exp->args)) == T_Aggreg)
|
|
|
|
if (nodeTag(nth(1, exp->args)) == T_Aggreg)
|
|
|
|
elog(ERROR, "rewrite: comparision of 2 aggregate columns not supported");
|
|
|
|
else
|
|
|
|
elog(ERROR, "rewrite: aggregate column of view must be at rigth side in qual");
|
|
|
|
|
|
|
|
aggreg = (Aggreg *)nth(1, exp->args);
|
|
|
|
target = (Var *)(aggreg->target);
|
|
|
|
rte = (RangeTblEntry *)nth(target->varno - 1, parsetree->rtable);
|
|
|
|
tle = makeNode(TargetEntry);
|
|
|
|
resdom = makeNode(Resdom);
|
|
|
|
|
|
|
|
aggreg->usenulls = TRUE;
|
|
|
|
|
|
|
|
resdom->resno = 1;
|
|
|
|
resdom->restype = ((Oper *)(exp->oper))->opresulttype;
|
|
|
|
resdom->restypmod = -1;
|
|
|
|
resdom->resname = pstrdup("<noname>");
|
|
|
|
resdom->reskey = 0;
|
|
|
|
resdom->reskeyop = 0;
|
|
|
|
resdom->resjunk = 0;
|
|
|
|
|
|
|
|
tle->resdom = resdom;
|
|
|
|
tle->expr = (Node *)aggreg;
|
|
|
|
|
|
|
|
subqual = copyObject(parsetree->qual);
|
|
|
|
modifyAggregDropQual((Node **)&subqual, (Node *)parsetree->qual, origexp);
|
|
|
|
|
|
|
|
sublink = makeNode(SubLink);
|
|
|
|
sublink->subLinkType = EXPR_SUBLINK;
|
|
|
|
sublink->useor = FALSE;
|
|
|
|
sublink->lefthand = lappend(NIL, copyObject(lfirst(exp->args)));
|
|
|
|
sublink->oper = lappend(NIL, copyObject(exp));
|
|
|
|
sublink->subselect = NULL;
|
|
|
|
|
|
|
|
subquery = makeNode(Query);
|
|
|
|
sublink->subselect = (Node *)subquery;
|
|
|
|
|
|
|
|
subquery->commandType = CMD_SELECT;
|
|
|
|
subquery->utilityStmt = NULL;
|
|
|
|
subquery->resultRelation = 0;
|
|
|
|
subquery->into = NULL;
|
|
|
|
subquery->isPortal = FALSE;
|
|
|
|
subquery->isBinary = FALSE;
|
|
|
|
subquery->unionall = FALSE;
|
|
|
|
subquery->uniqueFlag = NULL;
|
|
|
|
subquery->sortClause = NULL;
|
|
|
|
subquery->rtable = lappend(NIL, rte);
|
|
|
|
subquery->targetList = lappend(NIL, tle);
|
|
|
|
subquery->qual = subqual;
|
|
|
|
subquery->groupClause = NIL;
|
|
|
|
subquery->havingQual = NULL;
|
|
|
|
subquery->hasAggs = TRUE;
|
|
|
|
subquery->hasSubLinks = FALSE;
|
|
|
|
subquery->unionClause = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
modifyAggregUplevel((Node *)sublink);
|
|
|
|
|
|
|
|
modifyAggregChangeVarnodes((Node **)&(sublink->lefthand), target->varno,
|
|
|
|
1, target->varlevelsup);
|
|
|
|
modifyAggregChangeVarnodes((Node **)&(sublink->oper), target->varno,
|
|
|
|
1, target->varlevelsup);
|
|
|
|
modifyAggregChangeVarnodes((Node **)&(sublink->subselect), target->varno,
|
|
|
|
1, target->varlevelsup);
|
|
|
|
|
|
|
|
return sublink;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* modifyAggregQual -
|
|
|
|
* Search for qualification expressions that contain aggregate
|
|
|
|
* functions and substiture them by sublinks. These expressions
|
|
|
|
* originally come from qualifications that use aggregate columns
|
|
|
|
* of a view.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
modifyAggregQual(Node **nodePtr, Query *parsetree)
|
|
|
|
{
|
|
|
|
Node *node = *nodePtr;
|
|
|
|
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_Var:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Const:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_GroupClause:
|
|
|
|
{
|
|
|
|
GroupClause *grp = (GroupClause *)node;
|
|
|
|
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(grp->entry)),
|
|
|
|
parsetree);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
|
|
|
SubLink *sub;
|
|
|
|
|
|
|
|
|
|
|
|
if (length(exp->args) != 2) {
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(exp->args)),
|
|
|
|
parsetree);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nodeTag(nth(0, exp->args)) != T_Aggreg &&
|
|
|
|
nodeTag(nth(1, exp->args)) != T_Aggreg) {
|
|
|
|
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(exp->args)),
|
|
|
|
parsetree);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub = modifyAggregMakeSublink(exp,
|
|
|
|
parsetree);
|
|
|
|
|
|
|
|
*nodePtr = (Node *)sub;
|
|
|
|
parsetree->hasSubLinks = TRUE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
|
|
|
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(iter->iterexpr)),
|
|
|
|
parsetree);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(ref->refupperindexpr)),
|
|
|
|
parsetree);
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(ref->reflowerindexpr)),
|
|
|
|
parsetree);
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(ref->refexpr)),
|
|
|
|
parsetree);
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(ref->refassgnexpr)),
|
|
|
|
parsetree);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node)
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(lfirst(l))),
|
|
|
|
parsetree);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(sub->subselect)),
|
|
|
|
(Query *)(sub->subselect));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
|
|
|
{
|
|
|
|
Query *qry = (Query *)node;
|
|
|
|
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(qry->qual)),
|
|
|
|
parsetree);
|
|
|
|
|
|
|
|
modifyAggregQual(
|
|
|
|
(Node **)(&(qry->havingQual)),
|
|
|
|
parsetree);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in modifyAggregQual()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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))
|
|
|
|
return (tle->expr);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-10-21 18:21:29 +02:00
|
|
|
static void
|
|
|
|
apply_RIR_adjust_sublevel(Node *node, int sublevels_up)
|
|
|
|
{
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *)node;
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(tle->expr),
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(agg->target),
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_GroupClause:
|
|
|
|
{
|
|
|
|
GroupClause *grp = (GroupClause *)node;
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(grp->entry),
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(exp->args),
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(iter->iterexpr),
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(ref->refupperindexpr),
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(ref->reflowerindexpr),
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(ref->refexpr),
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)(ref->refassgnexpr),
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Var:
|
|
|
|
{
|
|
|
|
Var *var = (Var *)node;
|
|
|
|
|
|
|
|
var->varlevelsup = sublevels_up;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Const:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node) {
|
|
|
|
apply_RIR_adjust_sublevel(
|
|
|
|
(Node *)lfirst(l),
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in attribute_used()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
static void
|
|
|
|
apply_RIR_view(Node **nodePtr, int rt_index, RangeTblEntry *rte, List *tlist, int *modified, int sublevels_up)
|
|
|
|
{
|
|
|
|
Node *node = *nodePtr;
|
|
|
|
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(tle->expr)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(agg->target)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_GroupClause:
|
|
|
|
{
|
|
|
|
GroupClause *grp = (GroupClause *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(grp->entry)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(exp->args)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(iter->iterexpr)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(ref->refupperindexpr)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(ref->reflowerindexpr)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(ref->refexpr)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(ref->refassgnexpr)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Var:
|
|
|
|
{
|
|
|
|
Var *var = (Var *)node;
|
|
|
|
|
|
|
|
if (var->varlevelsup == sublevels_up &&
|
|
|
|
var->varno == rt_index) {
|
|
|
|
Node *exp;
|
|
|
|
|
1998-10-02 23:53:39 +02:00
|
|
|
if (var->varattno < 0)
|
|
|
|
elog(ERROR, "system column %s not available - %s is a view", get_attname(rte->relid, var->varattno), rte->relname);
|
1998-10-02 18:28:04 +02:00
|
|
|
exp = FindMatchingTLEntry(
|
|
|
|
tlist,
|
|
|
|
get_attname(rte->relid,
|
|
|
|
var->varattno));
|
|
|
|
|
|
|
|
if (exp == NULL) {
|
|
|
|
*nodePtr = make_null(var->vartype);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1998-10-20 19:21:44 +02:00
|
|
|
exp = copyObject(exp);
|
1998-10-21 18:21:29 +02:00
|
|
|
if (var->varlevelsup > 0)
|
|
|
|
apply_RIR_adjust_sublevel(exp, var->varlevelsup);
|
1998-10-02 18:28:04 +02:00
|
|
|
*nodePtr = exp;
|
|
|
|
*modified = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Const:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node)
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(lfirst(l))),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(sub->lefthand)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(sub->subselect)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up + 1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
|
|
|
{
|
|
|
|
Query *qry = (Query *)node;
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(qry->targetList)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(qry->qual)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(qry->havingQual)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
|
|
|
|
apply_RIR_view(
|
|
|
|
(Node **)(&(qry->groupClause)),
|
|
|
|
rt_index,
|
|
|
|
rte,
|
|
|
|
tlist,
|
|
|
|
modified,
|
|
|
|
sublevels_up);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in apply_RIR_view()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
ApplyRetrieveRule(Query *parsetree,
|
|
|
|
RewriteRule *rule,
|
|
|
|
int rt_index,
|
|
|
|
int relation_level,
|
|
|
|
Relation relation,
|
|
|
|
int *modified)
|
|
|
|
{
|
|
|
|
Query *rule_action = NULL;
|
|
|
|
Node *rule_qual;
|
|
|
|
List *rtable,
|
|
|
|
*rt;
|
|
|
|
int nothing,
|
|
|
|
rt_length;
|
|
|
|
int badsql = FALSE;
|
|
|
|
|
|
|
|
rule_qual = rule->qual;
|
|
|
|
if (rule->actions)
|
|
|
|
{
|
|
|
|
if (length(rule->actions) > 1) /* ??? because we don't handle
|
|
|
|
* rules with more than one
|
|
|
|
* action? -ay */
|
|
|
|
|
|
|
|
return;
|
|
|
|
rule_action = copyObject(lfirst(rule->actions));
|
|
|
|
nothing = FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
nothing = TRUE;
|
|
|
|
|
|
|
|
rtable = copyObject(parsetree->rtable);
|
|
|
|
foreach(rt, rtable)
|
|
|
|
{
|
|
|
|
RangeTblEntry *rte = lfirst(rt);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this is to prevent add_missing_vars_to_base_rels() from adding
|
|
|
|
* a bogus entry to the new target list.
|
|
|
|
*/
|
|
|
|
rte->inFromCl = false;
|
|
|
|
}
|
|
|
|
rt_length = length(rtable);
|
|
|
|
|
|
|
|
rtable = nconc(rtable, copyObject(rule_action->rtable));
|
|
|
|
parsetree->rtable = rtable;
|
|
|
|
|
|
|
|
rule_action->rtable = rtable;
|
1998-10-21 18:21:29 +02:00
|
|
|
OffsetVarNodes((Node *) rule_qual, rt_length, 0);
|
|
|
|
OffsetVarNodes((Node *) rule_action, rt_length, 0);
|
1998-10-02 18:28:04 +02:00
|
|
|
|
1998-10-21 18:21:29 +02:00
|
|
|
ChangeVarNodes((Node *) rule_qual,
|
1998-10-02 18:28:04 +02:00
|
|
|
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
1998-10-21 18:21:29 +02:00
|
|
|
ChangeVarNodes((Node *) rule_action,
|
1998-10-02 18:28:04 +02:00
|
|
|
PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
|
|
|
|
|
|
|
if (relation_level)
|
|
|
|
{
|
|
|
|
apply_RIR_view((Node **) &parsetree, rt_index,
|
|
|
|
(RangeTblEntry *)nth(rt_index - 1, rtable),
|
|
|
|
rule_action->targetList, modified, 0);
|
|
|
|
apply_RIR_view((Node **) &rule_action, rt_index,
|
|
|
|
(RangeTblEntry *)nth(rt_index - 1, rtable),
|
|
|
|
rule_action->targetList, modified, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
HandleRIRAttributeRule(parsetree, rtable, rule_action->targetList,
|
|
|
|
rt_index, rule->attrno, modified, &badsql);
|
|
|
|
}
|
|
|
|
if (*modified && !badsql) {
|
|
|
|
AddQual(parsetree, rule_action->qual);
|
|
|
|
/* This will only work if the query made to the view defined by the following
|
|
|
|
* groupClause groups by the same attributes or does not use group at all! */
|
|
|
|
if (parsetree->groupClause == NULL)
|
|
|
|
parsetree->groupClause=rule_action->groupClause;
|
|
|
|
AddHavingQual(parsetree, rule_action->havingQual);
|
|
|
|
parsetree->hasAggs = (rule_action->hasAggs || parsetree->hasAggs);
|
|
|
|
parsetree->hasSubLinks = (rule_action->hasSubLinks || parsetree->hasSubLinks);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
fireRIRonSubselect(Node *node)
|
|
|
|
{
|
|
|
|
if (node == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch(nodeTag(node)) {
|
|
|
|
case T_TargetEntry:
|
|
|
|
{
|
|
|
|
TargetEntry *tle = (TargetEntry *)node;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(tle->expr));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Aggreg:
|
|
|
|
{
|
|
|
|
Aggreg *agg = (Aggreg *)node;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(agg->target));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_GroupClause:
|
|
|
|
{
|
|
|
|
GroupClause *grp = (GroupClause *)node;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(grp->entry));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Expr:
|
|
|
|
{
|
|
|
|
Expr *exp = (Expr *)node;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(exp->args));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Iter:
|
|
|
|
{
|
|
|
|
Iter *iter = (Iter *)node;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(iter->iterexpr));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_ArrayRef:
|
|
|
|
{
|
|
|
|
ArrayRef *ref = (ArrayRef *)node;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(ref->refupperindexpr));
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(ref->reflowerindexpr));
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(ref->refexpr));
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(ref->refassgnexpr));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Var:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Param:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Const:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_List:
|
|
|
|
{
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
foreach (l, (List *)node)
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(lfirst(l)));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_SubLink:
|
|
|
|
{
|
|
|
|
SubLink *sub = (SubLink *)node;
|
|
|
|
Query *qry;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(sub->lefthand));
|
|
|
|
|
|
|
|
qry = fireRIRrules((Query *)(sub->subselect));
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)qry);
|
|
|
|
|
|
|
|
sub->subselect = (Node *) qry;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case T_Query:
|
|
|
|
{
|
|
|
|
Query *qry = (Query *)node;
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(qry->targetList));
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(qry->qual));
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(qry->havingQual));
|
|
|
|
|
|
|
|
fireRIRonSubselect(
|
|
|
|
(Node *)(qry->groupClause));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
elog(NOTICE, "unknown node tag %d in fireRIRonSubselect()", nodeTag(node));
|
|
|
|
elog(NOTICE, "Node is: %s", nodeToString(node));
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fireRIRrules -
|
|
|
|
* Apply all RIR rules on each rangetable entry in a query
|
|
|
|
*/
|
|
|
|
static Query *
|
|
|
|
fireRIRrules(Query *parsetree)
|
|
|
|
{
|
|
|
|
int rt_index;
|
|
|
|
RangeTblEntry *rte;
|
|
|
|
Relation rel;
|
|
|
|
List *locks;
|
|
|
|
RuleLock *rules;
|
|
|
|
RewriteRule *rule;
|
|
|
|
RewriteRule RIRonly;
|
|
|
|
int modified;
|
|
|
|
int i;
|
|
|
|
List *l;
|
|
|
|
|
|
|
|
rt_index = 0;
|
|
|
|
while(rt_index < length(parsetree->rtable)) {
|
|
|
|
++rt_index;
|
|
|
|
|
|
|
|
if (!rangeTableEntry_used((Node *)parsetree, rt_index, 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rte = nth(rt_index - 1, parsetree->rtable);
|
|
|
|
rel = heap_openr(rte->relname);
|
|
|
|
if (rel->rd_rules == NULL) {
|
|
|
|
heap_close(rel);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
rules = rel->rd_rules;
|
|
|
|
locks = NIL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Collect the RIR rules that we must apply
|
|
|
|
*/
|
|
|
|
for (i = 0; i < rules->numLocks; i++) {
|
|
|
|
rule = rules->rules[i];
|
|
|
|
if (rule->event != CMD_SELECT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (rule->attrno > 0 &&
|
|
|
|
!attribute_used((Node *)parsetree,
|
|
|
|
rt_index,
|
|
|
|
rule->attrno, 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
locks = lappend(locks, rule);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check permissions
|
|
|
|
*/
|
|
|
|
checkLockPerms(locks, parsetree, rt_index);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now apply them
|
|
|
|
*/
|
|
|
|
foreach (l, locks) {
|
|
|
|
rule = lfirst(l);
|
|
|
|
|
|
|
|
RIRonly.event = rule->event;
|
|
|
|
RIRonly.attrno = rule->attrno;
|
|
|
|
RIRonly.qual = rule->qual;
|
|
|
|
RIRonly.actions = rule->actions;
|
|
|
|
|
|
|
|
ApplyRetrieveRule(parsetree,
|
|
|
|
&RIRonly,
|
|
|
|
rt_index,
|
|
|
|
RIRonly.attrno == -1,
|
|
|
|
rel,
|
|
|
|
&modified);
|
|
|
|
}
|
|
|
|
|
|
|
|
heap_close(rel);
|
|
|
|
}
|
|
|
|
|
|
|
|
fireRIRonSubselect((Node *) parsetree);
|
|
|
|
modifyAggregQual((Node **) &(parsetree->qual), parsetree);
|
|
|
|
|
|
|
|
return parsetree;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* idea is to fire regular rules first, then qualified instead
|
|
|
|
* rules and unqualified instead rules last. Any lemming is counted for.
|
|
|
|
*/
|
|
|
|
static List *
|
|
|
|
orderRules(List *locks)
|
|
|
|
{
|
|
|
|
List *regular = NIL;
|
|
|
|
List *instead_rules = NIL;
|
|
|
|
List *instead_qualified = NIL;
|
|
|
|
List *i;
|
|
|
|
|
|
|
|
foreach(i, locks)
|
|
|
|
{
|
|
|
|
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
|
|
|
|
|
|
|
if (rule_lock->isInstead)
|
|
|
|
{
|
|
|
|
if (rule_lock->qual == NULL)
|
|
|
|
instead_rules = lappend(instead_rules, rule_lock);
|
|
|
|
else
|
|
|
|
instead_qualified = lappend(instead_qualified, rule_lock);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1998-10-02 18:28:04 +02:00
|
|
|
else
|
|
|
|
regular = lappend(regular, rule_lock);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1998-10-02 18:28:04 +02:00
|
|
|
regular = nconc(regular, instead_qualified);
|
|
|
|
return nconc(regular, instead_rules);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
static Query *
|
1997-09-08 23:56:23 +02:00
|
|
|
CopyAndAddQual(Query *parsetree,
|
|
|
|
List *actions,
|
|
|
|
Node *rule_qual,
|
1997-09-07 07:04:48 +02:00
|
|
|
int rt_index,
|
|
|
|
CmdType event)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
Query *new_tree = (Query *) copyObject(parsetree);
|
|
|
|
Node *new_qual = NULL;
|
|
|
|
Query *rule_action = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (actions)
|
|
|
|
rule_action = lfirst(actions);
|
|
|
|
if (rule_qual != NULL)
|
|
|
|
new_qual = (Node *) copyObject(rule_qual);
|
|
|
|
if (rule_action != NULL)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
List *rtable;
|
|
|
|
int rt_length;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
rtable = new_tree->rtable;
|
|
|
|
rt_length = length(rtable);
|
|
|
|
rtable = append(rtable, listCopy(rule_action->rtable));
|
|
|
|
new_tree->rtable = rtable;
|
1998-10-21 18:21:29 +02:00
|
|
|
OffsetVarNodes(new_qual, rt_length, 0);
|
1998-01-21 05:24:46 +01:00
|
|
|
ChangeVarNodes(new_qual, PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
/* XXX -- where current doesn't work for instead nothing.... yet */
|
|
|
|
AddNotQual(new_tree, new_qual);
|
|
|
|
|
|
|
|
return new_tree;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* fireRules -
|
1998-08-18 02:49:04 +02:00
|
|
|
* Iterate through rule locks applying rules.
|
|
|
|
* All rules create their own parsetrees. Instead rules
|
|
|
|
* with rule qualification save the original parsetree
|
|
|
|
* and add their negated qualification to it. Real instead
|
|
|
|
* rules finally throw away the original parsetree.
|
1998-09-01 06:40:42 +02:00
|
|
|
*
|
1998-08-18 02:49:04 +02:00
|
|
|
* remember: reality is for dead birds -- glass
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static List *
|
1997-09-08 23:56:23 +02:00
|
|
|
fireRules(Query *parsetree,
|
1997-09-07 07:04:48 +02:00
|
|
|
int rt_index,
|
|
|
|
CmdType event,
|
1997-09-08 23:56:23 +02:00
|
|
|
bool *instead_flag,
|
|
|
|
List *locks,
|
|
|
|
List **qual_products)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RewriteInfo *info;
|
|
|
|
List *results = NIL;
|
|
|
|
List *i;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/* choose rule to fire from list of rules */
|
|
|
|
if (locks == NIL)
|
|
|
|
{
|
1998-10-02 18:28:04 +02:00
|
|
|
return NIL;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-08-18 02:49:04 +02:00
|
|
|
locks = orderRules(locks); /* real instead rules last */
|
1997-09-07 07:04:48 +02:00
|
|
|
foreach(i, locks)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
|
|
|
|
Node *qual,
|
|
|
|
*event_qual;
|
|
|
|
List *actions;
|
|
|
|
List *r;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-08-24 03:38:11 +02:00
|
|
|
/*
|
1998-09-01 06:40:42 +02:00
|
|
|
* Instead rules change the resultRelation of the query. So the
|
|
|
|
* permission checks on the initial resultRelation would never be
|
|
|
|
* done (this is normally done in the executor deep down). So we
|
|
|
|
* must do it here. The result relations resulting from earlier
|
|
|
|
* rewrites are already checked against the rules eventrelation
|
|
|
|
* owner (during matchLocks) and have the skipAcl flag set.
|
1998-08-24 03:38:11 +02:00
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
if (rule_lock->isInstead &&
|
|
|
|
parsetree->commandType != CMD_SELECT)
|
|
|
|
{
|
|
|
|
RangeTblEntry *rte;
|
1998-08-24 03:38:11 +02:00
|
|
|
int32 acl_rc;
|
|
|
|
int32 reqperm;
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
switch (parsetree->commandType)
|
|
|
|
{
|
1998-08-24 03:38:11 +02:00
|
|
|
case CMD_INSERT:
|
|
|
|
reqperm = ACL_AP;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
reqperm = ACL_WR;
|
|
|
|
break;
|
|
|
|
}
|
1998-09-01 06:40:42 +02:00
|
|
|
|
|
|
|
rte = (RangeTblEntry *) nth(parsetree->resultRelation - 1,
|
|
|
|
parsetree->rtable);
|
|
|
|
if (!rte->skipAcl)
|
|
|
|
{
|
1998-08-24 03:38:11 +02:00
|
|
|
acl_rc = pg_aclcheck(rte->relname,
|
1998-09-01 06:40:42 +02:00
|
|
|
GetPgUserName(), reqperm);
|
|
|
|
if (acl_rc != ACLCHECK_OK)
|
|
|
|
{
|
1998-08-24 03:38:11 +02:00
|
|
|
elog(ERROR, "%s: %s",
|
1998-09-01 06:40:42 +02:00
|
|
|
rte->relname,
|
|
|
|
aclcheck_error_strings[acl_rc]);
|
1998-08-24 03:38:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/* multiple rule action time */
|
|
|
|
*instead_flag = rule_lock->isInstead;
|
|
|
|
event_qual = rule_lock->qual;
|
|
|
|
actions = rule_lock->actions;
|
1998-09-01 06:40:42 +02:00
|
|
|
if (event_qual != NULL && *instead_flag)
|
|
|
|
{
|
|
|
|
Query *qual_product;
|
|
|
|
RewriteInfo qual_info;
|
1998-08-18 02:49:04 +02:00
|
|
|
|
|
|
|
/* ----------
|
|
|
|
* If there are instead rules with qualifications,
|
|
|
|
* the original query is still performed. But all
|
|
|
|
* the negated rule qualifications of the instead
|
|
|
|
* rules are added so it does it's actions only
|
|
|
|
* in cases where the rule quals of all instead
|
|
|
|
* rules are false. Think of it as the default
|
|
|
|
* action in a case. We save this in *qual_products
|
|
|
|
* so deepRewriteQuery() can add it to the query
|
|
|
|
* list after we mangled it up enough.
|
|
|
|
* ----------
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
if (*qual_products == NIL)
|
1998-08-18 02:49:04 +02:00
|
|
|
qual_product = parsetree;
|
1998-09-01 06:40:42 +02:00
|
|
|
else
|
|
|
|
qual_product = (Query *) nth(0, *qual_products);
|
1998-08-18 02:49:04 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
qual_info.event = qual_product->commandType;
|
|
|
|
qual_info.new_varno = length(qual_product->rtable) + 2;
|
|
|
|
qual_product = CopyAndAddQual(qual_product,
|
|
|
|
actions,
|
|
|
|
event_qual,
|
|
|
|
rt_index,
|
|
|
|
event);
|
|
|
|
|
|
|
|
qual_info.rule_action = qual_product;
|
1998-08-18 02:49:04 +02:00
|
|
|
|
|
|
|
if (event == CMD_INSERT || event == CMD_UPDATE)
|
|
|
|
FixNew(&qual_info, qual_product);
|
|
|
|
|
|
|
|
*qual_products = lappend(NIL, qual_product);
|
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
foreach(r, actions)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
Query *rule_action = lfirst(r);
|
|
|
|
Node *rule_qual = copyObject(event_qual);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-08-18 02:49:04 +02:00
|
|
|
if (rule_action->commandType == CMD_NOTHING)
|
|
|
|
continue;
|
|
|
|
|
1998-10-21 18:21:29 +02:00
|
|
|
/*--------------------------------------------------
|
|
|
|
* We copy the qualifications of the parsetree
|
|
|
|
* to the action and vice versa. So force
|
|
|
|
* hasSubLinks if one of them has it.
|
|
|
|
*
|
|
|
|
* As of 6.4 only parsetree qualifications can
|
|
|
|
* have sublinks. If this changes, we must make
|
|
|
|
* this a node lookup at the end of rewriting.
|
|
|
|
*
|
|
|
|
* Jan
|
|
|
|
*--------------------------------------------------
|
|
|
|
*/
|
|
|
|
if (parsetree->hasSubLinks && !rule_action->hasSubLinks)
|
|
|
|
{
|
|
|
|
rule_action = copyObject(rule_action);
|
|
|
|
rule_action->hasSubLinks = TRUE;
|
|
|
|
}
|
|
|
|
if (!parsetree->hasSubLinks && rule_action->hasSubLinks)
|
|
|
|
{
|
|
|
|
parsetree->hasSubLinks = TRUE;
|
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*--------------------------------------------------
|
|
|
|
* Step 1:
|
|
|
|
* Rewrite current.attribute or current to tuple variable
|
|
|
|
* this appears to be done in parser?
|
|
|
|
*--------------------------------------------------
|
|
|
|
*/
|
|
|
|
info = gatherRewriteMeta(parsetree, rule_action, rule_qual,
|
|
|
|
rt_index, event, instead_flag);
|
|
|
|
|
|
|
|
/* handle escapable cases, or those handled by other code */
|
|
|
|
if (info->nothing)
|
|
|
|
{
|
|
|
|
if (*instead_flag)
|
|
|
|
return NIL;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->action == info->event &&
|
|
|
|
info->event == CMD_SELECT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
1998-08-18 02:49:04 +02:00
|
|
|
* Event Qualification forces copying of parsetree and
|
1997-09-07 07:04:48 +02:00
|
|
|
* splitting into two queries one w/rule_qual, one w/NOT
|
|
|
|
* rule_qual. Also add user query qual onto rule action
|
|
|
|
*/
|
|
|
|
qual = parsetree->qual;
|
|
|
|
AddQual(info->rule_action, qual);
|
|
|
|
|
|
|
|
if (info->rule_qual != NULL)
|
|
|
|
AddQual(info->rule_action, info->rule_qual);
|
|
|
|
|
|
|
|
/*--------------------------------------------------
|
|
|
|
* Step 2:
|
|
|
|
* Rewrite new.attribute w/ right hand side of target-list
|
|
|
|
* entry for appropriate field name in insert/update
|
|
|
|
*--------------------------------------------------
|
|
|
|
*/
|
|
|
|
if ((info->event == CMD_INSERT) || (info->event == CMD_UPDATE))
|
|
|
|
FixNew(info, parsetree);
|
|
|
|
|
|
|
|
/*--------------------------------------------------
|
|
|
|
* Step 3:
|
|
|
|
* rewriting due to retrieve rules
|
|
|
|
*--------------------------------------------------
|
|
|
|
*/
|
|
|
|
info->rule_action->rtable = info->rt;
|
1998-10-02 18:28:04 +02:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
ProcessRetrieveQuery(info->rule_action, info->rt,
|
|
|
|
&orig_instead_flag, TRUE);
|
1998-10-02 18:28:04 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*--------------------------------------------------
|
|
|
|
* Step 4
|
|
|
|
* Simplify? hey, no algorithm for simplification... let
|
|
|
|
* the planner do it.
|
|
|
|
*--------------------------------------------------
|
|
|
|
*/
|
|
|
|
results = lappend(results, info->rule_action);
|
|
|
|
|
|
|
|
pfree(info);
|
|
|
|
}
|
1998-08-18 02:49:04 +02:00
|
|
|
|
|
|
|
/* ----------
|
|
|
|
* If this was an unqualified instead rule,
|
|
|
|
* throw away an eventually saved 'default' parsetree
|
|
|
|
* ----------
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
if (event_qual == NULL && *instead_flag)
|
1998-08-18 02:49:04 +02:00
|
|
|
*qual_products = NIL;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
return results;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1998-08-18 02:49:04 +02:00
|
|
|
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
static List *
|
1997-09-08 23:56:23 +02:00
|
|
|
RewriteQuery(Query *parsetree, bool *instead_flag, List **qual_products)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
CmdType event;
|
1998-10-02 18:28:04 +02:00
|
|
|
List *product_queries = NIL;
|
|
|
|
int result_relation = 0;
|
|
|
|
RangeTblEntry *rt_entry;
|
|
|
|
Relation rt_entry_relation = NULL;
|
|
|
|
RuleLock *rt_entry_locks = NULL;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(parsetree != NULL);
|
|
|
|
|
|
|
|
event = parsetree->commandType;
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
/*
|
|
|
|
* SELECT rules are handled later when we have all the
|
|
|
|
* queries that should get executed
|
|
|
|
*/
|
|
|
|
if (event == CMD_SELECT)
|
|
|
|
return NIL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Utilities aren't rewritten at all - why is this here?
|
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (event == CMD_UTILITY)
|
|
|
|
return NIL;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* only for a delete may the targetlist be NULL
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (event != CMD_DELETE)
|
|
|
|
Assert(parsetree->targetList != NULL);
|
|
|
|
|
|
|
|
result_relation = parsetree->resultRelation;
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
/*
|
|
|
|
* the statement is an update, insert or delete - fire rules
|
|
|
|
* on it.
|
|
|
|
*/
|
|
|
|
rt_entry = rt_fetch(result_relation, parsetree->rtable);
|
|
|
|
rt_entry_relation = heap_openr(rt_entry->relname);
|
|
|
|
rt_entry_locks = rt_entry_relation->rd_rules;
|
|
|
|
heap_close(rt_entry_relation);
|
1998-08-18 02:49:04 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
if (rt_entry_locks != NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1998-10-02 18:28:04 +02:00
|
|
|
List *locks =
|
|
|
|
matchLocks(event, rt_entry_locks, result_relation, parsetree);
|
|
|
|
|
|
|
|
product_queries =
|
|
|
|
fireRules(parsetree,
|
|
|
|
result_relation,
|
|
|
|
event,
|
|
|
|
instead_flag,
|
|
|
|
locks,
|
|
|
|
qual_products);
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
return product_queries;
|
1998-01-09 06:48:22 +01:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1998-10-02 18:28:04 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* to avoid infinite recursion, we restrict the number of times a query
|
|
|
|
* can be rewritten. Detecting cycles is left for the reader as an excercise.
|
|
|
|
*/
|
|
|
|
#ifndef REWRITE_INVOKE_MAX
|
1997-09-07 07:04:48 +02:00
|
|
|
#define REWRITE_INVOKE_MAX 10
|
1996-07-09 08:22:35 +02:00
|
|
|
#endif
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
static int numQueryRewriteInvoked = 0;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* deepRewriteQuery -
|
1997-09-07 07:04:48 +02:00
|
|
|
* rewrites the query and apply the rules again on the queries rewritten
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static List *
|
1997-09-08 23:56:23 +02:00
|
|
|
deepRewriteQuery(Query *parsetree)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
List *n;
|
|
|
|
List *rewritten = NIL;
|
|
|
|
List *result = NIL;
|
|
|
|
bool instead;
|
|
|
|
List *qual_products = NIL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-03-30 18:36:43 +02:00
|
|
|
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (++numQueryRewriteInvoked > REWRITE_INVOKE_MAX)
|
|
|
|
{
|
1998-01-07 22:07:04 +01:00
|
|
|
elog(ERROR, "query rewritten %d times, may contain cycles",
|
1997-09-07 07:04:48 +02:00
|
|
|
numQueryRewriteInvoked - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
instead = FALSE;
|
|
|
|
result = RewriteQuery(parsetree, &instead, &qual_products);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
foreach(n, result)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
Query *pt = lfirst(n);
|
|
|
|
List *newstuff = NIL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
newstuff = deepRewriteQuery(pt);
|
|
|
|
if (newstuff != NIL)
|
|
|
|
rewritten = nconc(rewritten, newstuff);
|
|
|
|
}
|
1998-08-18 02:49:04 +02:00
|
|
|
|
|
|
|
/* ----------
|
|
|
|
* qual_products are the original query with the negated
|
|
|
|
* rule qualification of an instead rule
|
|
|
|
* ----------
|
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (qual_products != NIL)
|
|
|
|
rewritten = nconc(rewritten, qual_products);
|
|
|
|
|
1998-08-18 02:49:04 +02:00
|
|
|
/* ----------
|
|
|
|
* The original query is appended last if not instead
|
|
|
|
* because update and delete rule actions might not do
|
|
|
|
* anything if they are invoked after the update or
|
|
|
|
* delete is performed. The command counter increment
|
|
|
|
* between the query execution makes the deleted (and
|
|
|
|
* maybe the updated) tuples disappear so the scans
|
|
|
|
* for them in the rule actions cannot find them.
|
|
|
|
* ----------
|
|
|
|
*/
|
|
|
|
if (!instead)
|
|
|
|
rewritten = lappend(rewritten, parsetree);
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
return rewritten;
|
|
|
|
}
|
1998-10-02 18:28:04 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* QueryOneRewrite -
|
|
|
|
* rewrite one query
|
|
|
|
*/
|
|
|
|
static List *
|
|
|
|
QueryRewriteOne(Query *parsetree)
|
|
|
|
{
|
|
|
|
numQueryRewriteInvoked = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* take a deep breath and apply all the rewrite rules - ay
|
|
|
|
*/
|
|
|
|
return deepRewriteQuery(parsetree);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ----------
|
|
|
|
* RewritePreprocessQuery -
|
|
|
|
* adjust details in the parsetree, the rule system
|
|
|
|
* depends on
|
|
|
|
* ----------
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
RewritePreprocessQuery(Query *parsetree)
|
|
|
|
{
|
|
|
|
/* ----------
|
|
|
|
* if the query has a resultRelation, reassign the
|
|
|
|
* result domain numbers to the attribute numbers in the
|
|
|
|
* target relation. FixNew() depends on it when replacing
|
|
|
|
* *new* references in a rule action by the expressions
|
|
|
|
* from the rewritten query.
|
|
|
|
* ----------
|
|
|
|
*/
|
|
|
|
if (parsetree->resultRelation > 0)
|
|
|
|
{
|
|
|
|
RangeTblEntry *rte;
|
|
|
|
Relation rd;
|
|
|
|
List *tl;
|
|
|
|
TargetEntry *tle;
|
|
|
|
int resdomno;
|
|
|
|
|
|
|
|
rte = (RangeTblEntry *) nth(parsetree->resultRelation - 1,
|
|
|
|
parsetree->rtable);
|
|
|
|
rd = heap_openr(rte->relname);
|
|
|
|
|
|
|
|
foreach(tl, parsetree->targetList)
|
|
|
|
{
|
|
|
|
tle = (TargetEntry *) lfirst(tl);
|
|
|
|
resdomno = attnameAttNum(rd, tle->resdom->resname);
|
|
|
|
tle->resdom->resno = resdomno;
|
|
|
|
}
|
|
|
|
|
|
|
|
heap_close(rd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* QueryRewrite -
|
|
|
|
* rewrite one query via query rewrite system, possibly returning 0
|
|
|
|
* or many queries
|
|
|
|
*/
|
|
|
|
List *
|
|
|
|
QueryRewrite(Query *parsetree)
|
|
|
|
{
|
|
|
|
List *querylist;
|
|
|
|
List *results = NIL;
|
|
|
|
List *l;
|
|
|
|
Query *query;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Step 1
|
|
|
|
*
|
|
|
|
* There still seems something broken with the resdom numbers
|
|
|
|
* so we reassign them first.
|
|
|
|
*/
|
|
|
|
RewritePreprocessQuery(parsetree);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Step 2
|
|
|
|
*
|
|
|
|
* Apply all non-SELECT rules possibly getting 0 or many queries
|
|
|
|
*/
|
|
|
|
querylist = QueryRewriteOne(parsetree);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Step 3
|
|
|
|
*
|
|
|
|
* Apply all the RIR rules on each query
|
|
|
|
*/
|
|
|
|
foreach (l, querylist) {
|
|
|
|
query = (Query *)lfirst(l);
|
|
|
|
results = lappend(results, fireRIRrules(query));
|
|
|
|
}
|
|
|
|
|
|
|
|
return results;
|
|
|
|
}
|
|
|
|
|
|
|
|
|