* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994-5, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.70 2002/03/06 06:09:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.71 2002/03/12 00:51:35 tgl Exp $
*
*/
#include "executor/instrument.h"
#include "lib/stringinfo.h"
#include "nodes/print.h"
+#include "optimizer/clauses.h"
#include "optimizer/planner.h"
#include "parser/parsetree.h"
#include "rewrite/rewriteHandler.h"
#include "tcop/pquery.h"
+#include "utils/builtins.h"
#include "utils/relcache.h"
+
typedef struct ExplainState
{
/* options */
static StringInfo Explain_PlanToString(Plan *plan, ExplainState *es);
static void ExplainOneQuery(Query *query, bool verbose, bool analyze, CommandDest dest);
+static void show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
+ int scanrelid,
+ StringInfo str, int indent, ExplainState *es);
+static void show_upper_qual(List *qual, const char *qlabel,
+ const char *outer_name, int outer_varno, Plan *outer_plan,
+ const char *inner_name, int inner_varno, Plan *inner_plan,
+ StringInfo str, int indent, ExplainState *es);
+static Node *make_ors_ands_explicit(List *orclauses);
/* Convert a null string pointer into "<>" */
#define stringStringInfo(s) (((s) == NULL) ? "<>" : (s))
/*
* ExplainQuery -
* print out the execution plan for a given query
- *
*/
void
ExplainQuery(Query *query, bool verbose, bool analyze, CommandDest dest)
/*
* ExplainOneQuery -
* print out the execution plan for one query
- *
*/
static void
ExplainOneQuery(Query *query, bool verbose, bool analyze, CommandDest dest)
pfree(es);
}
-/*****************************************************************************
- *
- *****************************************************************************/
/*
* explain_outNode -
}
appendStringInfo(str, "\n");
+ /* quals */
+ switch (nodeTag(plan))
+ {
+ case T_IndexScan:
+ show_scan_qual(((IndexScan *) plan)->indxqualorig, true,
+ "indxqual",
+ ((Scan *) plan)->scanrelid,
+ str, indent, es);
+ show_scan_qual(plan->qual, false, "qual",
+ ((Scan *) plan)->scanrelid,
+ str, indent, es);
+ break;
+ case T_SeqScan:
+ case T_TidScan:
+ show_scan_qual(plan->qual, false, "qual",
+ ((Scan *) plan)->scanrelid,
+ str, indent, es);
+ break;
+ case T_NestLoop:
+ show_upper_qual(((NestLoop *) plan)->join.joinqual, "joinqual",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ show_upper_qual(plan->qual, "qual",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ break;
+ case T_MergeJoin:
+ show_upper_qual(((MergeJoin *) plan)->mergeclauses, "merge",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ show_upper_qual(((MergeJoin *) plan)->join.joinqual, "joinqual",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ show_upper_qual(plan->qual, "qual",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ break;
+ case T_HashJoin:
+ show_upper_qual(((HashJoin *) plan)->hashclauses, "hash",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ show_upper_qual(((HashJoin *) plan)->join.joinqual, "joinqual",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ show_upper_qual(plan->qual, "qual",
+ "outer", OUTER, outerPlan(plan),
+ "inner", INNER, innerPlan(plan),
+ str, indent, es);
+ break;
+ case T_SubqueryScan:
+ show_upper_qual(plan->qual, "qual",
+ "subplan", 1, ((SubqueryScan *) plan)->subplan,
+ "", 0, NULL,
+ str, indent, es);
+ break;
+ case T_Agg:
+ case T_Group:
+ show_upper_qual(plan->qual, "qual",
+ "subplan", 0, outerPlan(plan),
+ "", 0, NULL,
+ str, indent, es);
+ break;
+ case T_Result:
+ show_upper_qual((List *) ((Result *) plan)->resconstantqual,
+ "constqual",
+ "subplan", OUTER, outerPlan(plan),
+ "", 0, NULL,
+ str, indent, es);
+ show_upper_qual(plan->qual, "qual",
+ "subplan", OUTER, outerPlan(plan),
+ "", 0, NULL,
+ str, indent, es);
+ break;
+ default:
+ break;
+ }
+
/* initPlan-s */
if (plan->initPlan)
{
explain_outNode(str, plan, 0, es);
return str;
}
+
+/*
+ * Show a qualifier expression for a scan plan node
+ */
+static void
+show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
+ int scanrelid,
+ StringInfo str, int indent, ExplainState *es)
+{
+ RangeTblEntry *rte;
+ List *context;
+ Node *node;
+ char *exprstr;
+ int i;
+
+ /* No work if empty qual */
+ if (qual == NIL)
+ return;
+ if (is_or_qual)
+ {
+ if (lfirst(qual) == NIL && lnext(qual) == NIL)
+ return;
+ }
+
+ /* Generate deparse context */
+ Assert(scanrelid > 0 && scanrelid <= length(es->rtable));
+ rte = rt_fetch(scanrelid, es->rtable);
+
+ /* Assume it's on a real relation */
+ Assert(rte->relname);
+
+ context = deparse_context_for(rte->relname, rte->relid);
+
+ /* Fix qual --- indexqual requires different processing */
+ if (is_or_qual)
+ node = make_ors_ands_explicit(qual);
+ else
+ node = (Node *) make_ands_explicit(qual);
+
+ /* Deparse the expression */
+ exprstr = deparse_expression(node, context, false);
+
+ /* And add to str */
+ for (i = 0; i < indent; i++)
+ appendStringInfo(str, " ");
+ appendStringInfo(str, " %s: %s\n", qlabel, exprstr);
+}
+
+/*
+ * Show a qualifier expression for an upper-level plan node
+ */
+static void
+show_upper_qual(List *qual, const char *qlabel,
+ const char *outer_name, int outer_varno, Plan *outer_plan,
+ const char *inner_name, int inner_varno, Plan *inner_plan,
+ StringInfo str, int indent, ExplainState *es)
+{
+ List *context;
+ Node *outercontext;
+ Node *innercontext;
+ Node *node;
+ char *exprstr;
+ int i;
+
+ /* No work if empty qual */
+ if (qual == NIL)
+ return;
+
+ /* Generate deparse context */
+ if (outer_plan)
+ outercontext = deparse_context_for_subplan(outer_name,
+ outer_plan->targetlist,
+ es->rtable);
+ else
+ outercontext = NULL;
+ if (inner_plan)
+ innercontext = deparse_context_for_subplan(inner_name,
+ inner_plan->targetlist,
+ es->rtable);
+ else
+ innercontext = NULL;
+ context = deparse_context_for_plan(outer_varno, outercontext,
+ inner_varno, innercontext);
+
+ /* Deparse the expression */
+ node = (Node *) make_ands_explicit(qual);
+ exprstr = deparse_expression(node, context, (inner_plan != NULL));
+
+ /* And add to str */
+ for (i = 0; i < indent; i++)
+ appendStringInfo(str, " ");
+ appendStringInfo(str, " %s: %s\n", qlabel, exprstr);
+}
+
+/*
+ * Indexscan qual lists have an implicit OR-of-ANDs structure. Make it
+ * explicit so deparsing works properly.
+ */
+static Node *
+make_ors_ands_explicit(List *orclauses)
+{
+ if (orclauses == NIL)
+ return NULL; /* probably can't happen */
+ else if (lnext(orclauses) == NIL)
+ return (Node *) make_ands_explicit(lfirst(orclauses));
+ else
+ {
+ List *args = NIL;
+ List *orptr;
+
+ foreach(orptr, orclauses)
+ {
+ args = lappend(args, make_ands_explicit(lfirst(orptr)));
+ }
+
+ return (Node *) make_orclause(args);
+ }
+}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.168 2002/03/08 04:37:16 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.169 2002/03/12 00:51:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
newnode->jointype = from->jointype;
Node_Copy(from, newnode, joinqual);
+ newnode->joinrti = from->joinrti;
/* subPlan list must point to subplans in the new subtree, not the old */
if (from->plan.subPlan != NIL)
newnode->plan.subPlan = nconc(newnode->plan.subPlan,
Node_Copy(from, newnode, using);
Node_Copy(from, newnode, quals);
Node_Copy(from, newnode, alias);
- Node_Copy(from, newnode, colnames);
- Node_Copy(from, newnode, colvars);
+ newnode->rtindex = from->rtindex;
return newnode;
}
* _copyRelOptInfo
* ----------------
*/
-/*
- * when you change this, also make sure to fix up xfunc_copyRelOptInfo in
- * planner/path/xfunc.c accordingly!!!
- * -- JMH, 8/2/93
- */
static RelOptInfo *
_copyRelOptInfo(RelOptInfo *from)
{
RelOptInfo *newnode = makeNode(RelOptInfo);
+ newnode->reloptkind = from->reloptkind;
+
newnode->relids = listCopy(from->relids);
newnode->rows = from->rows;
newnode->tuples = from->tuples;
Node_Copy(from, newnode, subplan);
+ newnode->joinrti = from->joinrti;
+ newnode->joinrteids = listCopy(from->joinrteids);
+
Node_Copy(from, newnode, baserestrictinfo);
newnode->baserestrictcost = from->baserestrictcost;
newnode->outerjoinset = listCopy(from->outerjoinset);
{
RangeTblEntry *newnode = makeNode(RangeTblEntry);
+ newnode->rtekind = from->rtekind;
if (from->relname)
newnode->relname = pstrdup(from->relname);
newnode->relid = from->relid;
Node_Copy(from, newnode, subquery);
+ newnode->jointype = from->jointype;
+ newnode->joincoltypes = listCopy(from->joincoltypes);
+ newnode->joincoltypmods = listCopy(from->joincoltypmods);
+ newnode->joinleftcols = listCopy(from->joinleftcols);
+ newnode->joinrightcols = listCopy(from->joinrightcols);
Node_Copy(from, newnode, alias);
Node_Copy(from, newnode, eref);
newnode->inh = from->inh;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.116 2002/03/08 04:37:16 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.117 2002/03/12 00:51:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return false;
if (!equal(a->alias, b->alias))
return false;
- if (!equal(a->colnames, b->colnames))
- return false;
- if (!equal(a->colvars, b->colvars))
+ if (a->rtindex != b->rtindex)
return false;
return true;
static bool
_equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
{
+ if (a->rtekind != b->rtekind)
+ return false;
if (!equalstr(a->relname, b->relname))
return false;
if (a->relid != b->relid)
return false;
if (!equal(a->subquery, b->subquery))
return false;
+ if (a->jointype != b->jointype)
+ return false;
+ if (!equali(a->joincoltypes, b->joincoltypes))
+ return false;
+ if (!equali(a->joincoltypmods, b->joincoltypmods))
+ return false;
+ if (!equali(a->joinleftcols, b->joinleftcols))
+ return false;
+ if (!equali(a->joinrightcols, b->joinrightcols))
+ return false;
if (!equal(a->alias, b->alias))
return false;
if (!equal(a->eref, b->eref))
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.148 2002/03/06 06:09:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.149 2002/03/12 00:51:39 tgl Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
appendStringInfo(str, " :jointype %d :joinqual ",
(int) node->jointype);
_outNode(str, node->joinqual);
+ appendStringInfo(str, " :joinrti %d ",
+ node->joinrti);
}
/*
appendStringInfo(str, " :jointype %d :joinqual ",
(int) node->join.jointype);
_outNode(str, node->join.joinqual);
+ appendStringInfo(str, " :joinrti %d ",
+ node->join.joinrti);
}
/*
appendStringInfo(str, " :jointype %d :joinqual ",
(int) node->join.jointype);
_outNode(str, node->join.joinqual);
+ appendStringInfo(str, " :joinrti %d ",
+ node->join.joinrti);
appendStringInfo(str, " :mergeclauses ");
_outNode(str, node->mergeclauses);
appendStringInfo(str, " :jointype %d :joinqual ",
(int) node->join.jointype);
_outNode(str, node->join.joinqual);
+ appendStringInfo(str, " :joinrti %d ",
+ node->join.joinrti);
appendStringInfo(str, " :hashclauses ");
_outNode(str, node->hashclauses);
_outNode(str, node->quals);
appendStringInfo(str, " :alias ");
_outNode(str, node->alias);
- appendStringInfo(str, " :colnames ");
- _outNode(str, node->colnames);
- appendStringInfo(str, " :colvars ");
- _outNode(str, node->colvars);
+ appendStringInfo(str, " :rtindex %d ", node->rtindex);
}
/*
static void
_outRangeTblEntry(StringInfo str, RangeTblEntry *node)
{
- appendStringInfo(str, " RTE :relname ");
+ appendStringInfo(str, " RTE :rtekind %d :relname ",
+ (int) node->rtekind);
_outToken(str, node->relname);
- appendStringInfo(str, " :relid %u ",
+ appendStringInfo(str, " :relid %u :subquery ",
node->relid);
- appendStringInfo(str, " :subquery ");
_outNode(str, node->subquery);
+ appendStringInfo(str, " :jointype %d :joincoltypes ",
+ (int) node->jointype);
+ _outOidList(str, node->joincoltypes);
+ appendStringInfo(str, " :joincoltypmods ");
+ _outIntList(str, node->joincoltypmods);
+ appendStringInfo(str, " :joinleftcols ");
+ _outIntList(str, node->joinleftcols);
+ appendStringInfo(str, " :joinrightcols ");
+ _outIntList(str, node->joinrightcols);
appendStringInfo(str, " :alias ");
_outNode(str, node->alias);
appendStringInfo(str, " :eref ");
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.115 2002/03/01 06:01:18 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.116 2002/03/12 00:51:39 tgl Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
token = pg_strtok(&length); /* skip the :joinqual */
node->joinqual = nodeRead(true); /* get the joinqual */
+
+ token = pg_strtok(&length); /* skip the :joinrti */
+ token = pg_strtok(&length); /* get the joinrti */
+ node->joinrti = atoi(token);
}
local_node->jointype = (JoinType) atoi(token);
token = pg_strtok(&length); /* eat :isNatural */
- token = pg_strtok(&length); /* get :isNatural */
+ token = pg_strtok(&length); /* get isNatural */
local_node->isNatural = strtobool(token);
token = pg_strtok(&length); /* eat :larg */
token = pg_strtok(&length); /* eat :alias */
local_node->alias = nodeRead(true); /* now read it */
- token = pg_strtok(&length); /* eat :colnames */
- local_node->colnames = nodeRead(true); /* now read it */
-
- token = pg_strtok(&length); /* eat :colvars */
- local_node->colvars = nodeRead(true); /* now read it */
+ token = pg_strtok(&length); /* eat :rtindex */
+ token = pg_strtok(&length); /* get rtindex */
+ local_node->rtindex = atoi(token);
return local_node;
}
local_node = makeNode(RangeTblEntry);
+ token = pg_strtok(&length); /* eat :rtekind */
+ token = pg_strtok(&length); /* get :rtekind */
+ local_node->rtekind = (RTEKind) atoi(token);
+
token = pg_strtok(&length); /* eat :relname */
token = pg_strtok(&length); /* get :relname */
local_node->relname = nullable_string(token, length);
token = pg_strtok(&length); /* eat :subquery */
local_node->subquery = nodeRead(true); /* now read it */
+ token = pg_strtok(&length); /* eat :jointype */
+ token = pg_strtok(&length); /* get jointype */
+ local_node->jointype = (JoinType) atoi(token);
+
+ token = pg_strtok(&length); /* eat :joincoltypes */
+ local_node->joincoltypes = toOidList(nodeRead(true));
+
+ token = pg_strtok(&length); /* eat :joincoltypmods */
+ local_node->joincoltypmods = toIntList(nodeRead(true));
+
+ token = pg_strtok(&length); /* eat :joinleftcols */
+ local_node->joinleftcols = toIntList(nodeRead(true));
+
+ token = pg_strtok(&length); /* eat :joinrightcols */
+ local_node->joinrightcols = toIntList(nodeRead(true));
+
token = pg_strtok(&length); /* eat :alias */
local_node->alias = nodeRead(true); /* now read it */
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.82 2002/03/01 20:50:20 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.83 2002/03/12 00:51:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
leftvar = get_leftop(firstclause->clause);
Assert(IsA(leftvar, Var));
- if (intMember(leftvar->varno, outer_path->parent->relids))
+ if (VARISRELMEMBER(leftvar->varno, outer_path->parent))
{
/* left side of clause is outer */
outerscansel = firstclause->left_mergescansel;
* a large query, we cache the bucketsize estimate in the RestrictInfo
* node to avoid repeated lookups of statistics.
*/
- if (intMember(right->varno, inner_path->parent->relids))
+ if (VARISRELMEMBER(right->varno, inner_path->parent))
{
/* righthand side is inner */
innerbucketsize = restrictinfo->right_bucketsize;
}
else
{
- Assert(intMember(left->varno, inner_path->parent->relids));
+ Assert(VARISRELMEMBER(left->varno, inner_path->parent));
/* lefthand side is inner */
innerbucketsize = restrictinfo->left_bucketsize;
if (innerbucketsize < 0)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.67 2001/11/11 19:18:54 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.68 2002/03/12 00:51:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parsetree.h"
#include "utils/lsyscache.h"
+
static void sort_inner_and_outer(Query *root, RelOptInfo *joinrel,
RelOptInfo *outerrel, RelOptInfo *innerrel,
List *restrictlist, List *mergeclause_list,
List *restrictlist,
JoinType jointype)
{
- Relids outerrelids = outerrel->relids;
- Relids innerrelids = innerrel->relids;
bool isouterjoin;
List *i;
/*
* Check if clause is usable with these input rels.
*/
- if (intMember(left->varno, outerrelids) &&
- intMember(right->varno, innerrelids))
+ if (VARISRELMEMBER(left->varno, outerrel) &&
+ VARISRELMEMBER(right->varno, innerrel))
{
/* righthand side is inner */
}
- else if (intMember(left->varno, innerrelids) &&
- intMember(right->varno, outerrelids))
+ else if (VARISRELMEMBER(left->varno, innerrel) &&
+ VARISRELMEMBER(right->varno, outerrel))
{
/* lefthand side is inner */
}
JoinType jointype)
{
List *result_list = NIL;
- Relids outerrelids = outerrel->relids;
- Relids innerrelids = innerrel->relids;
bool isouterjoin = IS_OUTER_JOIN(jointype);
List *i;
left = get_leftop(clause);
right = get_rightop(clause);
- if ((intMember(left->varno, outerrelids) &&
- intMember(right->varno, innerrelids)) ||
- (intMember(left->varno, innerrelids) &&
- intMember(right->varno, outerrelids)))
+ if ((VARISRELMEMBER(left->varno, outerrel) &&
+ VARISRELMEMBER(right->varno, innerrel)) ||
+ (VARISRELMEMBER(left->varno, innerrel) &&
+ VARISRELMEMBER(right->varno, outerrel)))
result_list = lcons(restrictinfo, result_list);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.55 2001/10/25 05:49:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.56 2002/03/12 00:51:44 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
int varno = ((RangeTblRef *) jtnode)->rtindex;
- return build_base_rel(root, varno);
+ return find_base_rel(root, varno);
}
else if (IsA(jtnode, FromExpr))
{
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.36 2001/11/11 20:33:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.37 2002/03/12 00:51:44 tgl Exp $
*
*-------------------------------------------------------------------------
*/
cache_mergeclause_pathkeys(root, restrictinfo);
key = (Node *) get_leftop(restrictinfo->clause);
- if (IsA(key, Var) &&intMember(((Var *) key)->varno, rel->relids))
+ if (IsA(key, Var) &&
+ VARISRELMEMBER(((Var *) key)->varno, rel))
{
/* Rel is left side of mergeclause */
pathkey = restrictinfo->left_pathkey;
else
{
key = (Node *) get_rightop(restrictinfo->clause);
- if (IsA(key, Var) &&intMember(((Var *) key)->varno, rel->relids))
+ if (IsA(key, Var) &&
+ VARISRELMEMBER(((Var *) key)->varno, rel))
{
/* Rel is right side of mergeclause */
pathkey = restrictinfo->right_pathkey;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.111 2001/10/28 06:25:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.112 2002/03/12 00:51:45 tgl Exp $
*
*-------------------------------------------------------------------------
*/
List *scan_clauses);
static SubqueryScan *create_subqueryscan_plan(Path *best_path,
List *tlist, List *scan_clauses);
-static NestLoop *create_nestloop_plan(NestPath *best_path, List *tlist,
+static NestLoop *create_nestloop_plan(Query *root,
+ NestPath *best_path, List *tlist,
List *joinclauses, List *otherclauses,
Plan *outer_plan, List *outer_tlist,
Plan *inner_plan, List *inner_tlist);
List *joinclauses, List *otherclauses,
Plan *outer_plan, List *outer_tlist,
Plan *inner_plan, List *inner_tlist);
-static HashJoin *create_hashjoin_plan(HashPath *best_path, List *tlist,
+static HashJoin *create_hashjoin_plan(Query *root,
+ HashPath *best_path, List *tlist,
List *joinclauses, List *otherclauses,
Plan *outer_plan, List *outer_tlist,
Plan *inner_plan, List *inner_tlist);
static NestLoop *make_nestloop(List *tlist,
List *joinclauses, List *otherclauses,
Plan *lefttree, Plan *righttree,
- JoinType jointype);
+ JoinType jointype, Index joinrti);
static HashJoin *make_hashjoin(List *tlist,
List *joinclauses, List *otherclauses,
List *hashclauses,
Plan *lefttree, Plan *righttree,
- JoinType jointype);
+ JoinType jointype, Index joinrti);
static Hash *make_hash(List *tlist, Node *hashkey, Plan *lefttree);
static MergeJoin *make_mergejoin(List *tlist,
List *joinclauses, List *otherclauses,
List *mergeclauses,
Plan *lefttree, Plan *righttree,
- JoinType jointype);
+ JoinType jointype, Index joinrti);
/*
* create_plan
inner_tlist);
break;
case T_HashJoin:
- plan = (Join *) create_hashjoin_plan((HashPath *) best_path,
+ plan = (Join *) create_hashjoin_plan(root,
+ (HashPath *) best_path,
join_tlist,
joinclauses,
otherclauses,
inner_tlist);
break;
case T_NestLoop:
- plan = (Join *) create_nestloop_plan((NestPath *) best_path,
+ plan = (Join *) create_nestloop_plan(root,
+ (NestPath *) best_path,
join_tlist,
joinclauses,
otherclauses,
*****************************************************************************/
static NestLoop *
-create_nestloop_plan(NestPath *best_path,
+create_nestloop_plan(Query *root,
+ NestPath *best_path,
List *tlist,
List *joinclauses,
List *otherclauses,
List *inner_tlist)
{
NestLoop *join_plan;
+ Index joinrti = best_path->path.parent->joinrti;
if (IsA(inner_plan, IndexScan))
{
/* only refs to outer vars get changed in the inner indexqual */
innerscan->indxqualorig = join_references(indxqualorig,
+ root,
outer_tlist,
NIL,
- innerrel);
+ innerrel,
+ joinrti);
innerscan->indxqual = join_references(innerscan->indxqual,
+ root,
outer_tlist,
NIL,
- innerrel);
+ innerrel,
+ joinrti);
/* fix the inner qpqual too, if it has join clauses */
if (NumRelids((Node *) inner_plan->qual) > 1)
inner_plan->qual = join_references(inner_plan->qual,
+ root,
outer_tlist,
NIL,
- innerrel);
+ innerrel,
+ joinrti);
}
}
else if (IsA(inner_plan, TidScan))
TidScan *innerscan = (TidScan *) inner_plan;
innerscan->tideval = join_references(innerscan->tideval,
+ root,
outer_tlist,
inner_tlist,
- innerscan->scan.scanrelid);
+ innerscan->scan.scanrelid,
+ joinrti);
}
else if (IsA_Join(inner_plan))
{
* Set quals to contain INNER/OUTER var references.
*/
joinclauses = join_references(joinclauses,
+ root,
outer_tlist,
inner_tlist,
- (Index) 0);
+ (Index) 0,
+ joinrti);
otherclauses = join_references(otherclauses,
+ root,
outer_tlist,
inner_tlist,
- (Index) 0);
+ (Index) 0,
+ joinrti);
join_plan = make_nestloop(tlist,
joinclauses,
otherclauses,
outer_plan,
inner_plan,
- best_path->jointype);
+ best_path->jointype,
+ joinrti);
copy_path_costsize(&join_plan->join.plan, &best_path->path);
{
List *mergeclauses;
MergeJoin *join_plan;
+ Index joinrti = best_path->jpath.path.parent->joinrti;
mergeclauses = get_actual_clauses(best_path->path_mergeclauses);
* clauses to contain INNER/OUTER var references.
*/
joinclauses = join_references(set_difference(joinclauses, mergeclauses),
+ root,
outer_tlist,
inner_tlist,
- (Index) 0);
+ (Index) 0,
+ joinrti);
/*
* Fix the additional qpquals too.
*/
otherclauses = join_references(otherclauses,
+ root,
outer_tlist,
inner_tlist,
- (Index) 0);
+ (Index) 0,
+ joinrti);
/*
* Now set the references in the mergeclauses and rearrange them so
* that the outer variable is always on the left.
*/
mergeclauses = switch_outer(join_references(mergeclauses,
+ root,
outer_tlist,
inner_tlist,
- (Index) 0));
+ (Index) 0,
+ joinrti));
/*
* Create explicit sort nodes for the outer and inner join paths if
mergeclauses,
outer_plan,
inner_plan,
- best_path->jpath.jointype);
+ best_path->jpath.jointype,
+ joinrti);
copy_path_costsize(&join_plan->join.plan, &best_path->jpath.path);
}
static HashJoin *
-create_hashjoin_plan(HashPath *best_path,
+create_hashjoin_plan(Query *root,
+ HashPath *best_path,
List *tlist,
List *joinclauses,
List *otherclauses,
HashJoin *join_plan;
Hash *hash_plan;
Node *innerhashkey;
+ Index joinrti = best_path->jpath.path.parent->joinrti;
/*
* NOTE: there will always be exactly one hashclause in the list
* clauses to contain INNER/OUTER var references.
*/
joinclauses = join_references(set_difference(joinclauses, hashclauses),
+ root,
outer_tlist,
inner_tlist,
- (Index) 0);
+ (Index) 0,
+ joinrti);
/*
* Fix the additional qpquals too.
*/
otherclauses = join_references(otherclauses,
+ root,
outer_tlist,
inner_tlist,
- (Index) 0);
+ (Index) 0,
+ joinrti);
/*
* Now set the references in the hashclauses and rearrange them so
* that the outer variable is always on the left.
*/
hashclauses = switch_outer(join_references(hashclauses,
+ root,
outer_tlist,
inner_tlist,
- (Index) 0));
+ (Index) 0,
+ joinrti));
/* Now the righthand op of the sole hashclause is the inner hash key. */
innerhashkey = (Node *) get_rightop(lfirst(hashclauses));
hashclauses,
outer_plan,
(Plan *) hash_plan,
- best_path->jpath.jointype);
+ best_path->jpath.jointype,
+ joinrti);
copy_path_costsize(&join_plan->join.plan, &best_path->jpath.path);
List *otherclauses,
Plan *lefttree,
Plan *righttree,
- JoinType jointype)
+ JoinType jointype,
+ Index joinrti)
{
NestLoop *node = makeNode(NestLoop);
Plan *plan = &node->join.plan;
plan->righttree = righttree;
node->join.jointype = jointype;
node->join.joinqual = joinclauses;
+ node->join.joinrti = joinrti;
return node;
}
List *hashclauses,
Plan *lefttree,
Plan *righttree,
- JoinType jointype)
+ JoinType jointype,
+ Index joinrti)
{
HashJoin *node = makeNode(HashJoin);
Plan *plan = &node->join.plan;
node->hashclauses = hashclauses;
node->join.jointype = jointype;
node->join.joinqual = joinclauses;
+ node->join.joinrti = joinrti;
return node;
}
List *mergeclauses,
Plan *lefttree,
Plan *righttree,
- JoinType jointype)
+ JoinType jointype,
+ Index joinrti)
{
MergeJoin *node = makeNode(MergeJoin);
Plan *plan = &node->join.plan;
node->mergeclauses = mergeclauses;
node->join.jointype = jointype;
node->join.joinqual = joinclauses;
+ node->join.joinrti = joinrti;
return node;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.66 2002/03/01 06:01:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.67 2002/03/12 00:51:45 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*****************************************************************************
*
- * TARGET LISTS
+ * JOIN TREES
*
*****************************************************************************/
/*
- * build_base_rel_tlists
- * Creates rel nodes for every relation mentioned in the target list
- * 'tlist' (if a node hasn't already been created) and adds them to
- * root->base_rel_list. Creates targetlist entries for each var seen
- * in 'tlist' and adds them to the tlist of the appropriate rel node.
- */
-void
-build_base_rel_tlists(Query *root, List *tlist)
-{
- List *tlist_vars = pull_var_clause((Node *) tlist, false);
-
- add_vars_to_targetlist(root, tlist_vars);
- freeList(tlist_vars);
-}
-
-/*
- * add_vars_to_targetlist
- * For each variable appearing in the list, add it to the relation's
- * targetlist if not already present. Corresponding base rel nodes
- * will be created if not already present.
- */
-static void
-add_vars_to_targetlist(Query *root, List *vars)
-{
- List *temp;
-
- foreach(temp, vars)
- {
- Var *var = (Var *) lfirst(temp);
- RelOptInfo *rel = build_base_rel(root, var->varno);
-
- add_var_to_tlist(rel, var);
- }
-}
-
-/*----------
- * add_missing_rels_to_query
+ * add_base_rels_to_query
+ *
+ * Scan the query's jointree and create baserel RelOptInfos for all
+ * the base relations (ie, table and subquery RTEs) appearing in the
+ * jointree. Also, create otherrel RelOptInfos for join RTEs.
*
- * If we have a relation listed in the join tree that does not appear
- * in the target list nor qualifications, we must add it to the base
- * relation list so that it can be processed. For instance,
- * select count(*) from foo;
- * would fail to scan foo if this routine were not called. More subtly,
- * select f.x from foo f, foo f2
- * is a join of f and f2. Note that if we have
- * select foo.x from foo f
- * this also gets turned into a join (between foo as foo and foo as f).
+ * The return value is a list of all the baserel indexes (but not join RTE
+ * indexes) included in the scanned jointree. This is actually just an
+ * internal convenience for marking join otherrels properly; no outside
+ * caller uses the result.
*
- * Returns a list of all the base relations (RelOptInfo nodes) that appear
- * in the join tree. This list can be used for cross-checking in the
- * reverse direction, ie, that we have a join tree entry for every
- * relation used in the query.
- *----------
+ * At the end of this process, there should be one baserel RelOptInfo for
+ * every non-join RTE that is used in the query. Therefore, this routine
+ * is the only place that should call build_base_rel. But build_other_rel
+ * will be used again later to build rels for inheritance children.
*/
List *
-add_missing_rels_to_query(Query *root, Node *jtnode)
+add_base_rels_to_query(Query *root, Node *jtnode)
{
List *result = NIL;
{
int varno = ((RangeTblRef *) jtnode)->rtindex;
- /* This call to build_base_rel does the primary work... */
- RelOptInfo *rel = build_base_rel(root, varno);
-
- result = makeList1(rel);
+ build_base_rel(root, varno);
+ result = makeListi1(varno);
}
else if (IsA(jtnode, FromExpr))
{
foreach(l, f->fromlist)
{
result = nconc(result,
- add_missing_rels_to_query(root, lfirst(l)));
+ add_base_rels_to_query(root, lfirst(l)));
}
}
else if (IsA(jtnode, JoinExpr))
{
JoinExpr *j = (JoinExpr *) jtnode;
+ RelOptInfo *jrel;
- result = add_missing_rels_to_query(root, j->larg);
+ result = add_base_rels_to_query(root, j->larg);
result = nconc(result,
- add_missing_rels_to_query(root, j->rarg));
+ add_base_rels_to_query(root, j->rarg));
+ /* the join's own rtindex is NOT added to result */
+ jrel = build_other_rel(root, j->rtindex);
+ /*
+ * Mark the join's otherrel with outerjoinset = list of baserel ids
+ * included in the join. Note we must copy here because result list
+ * is destructively modified by nconcs at higher levels.
+ */
+ jrel->outerjoinset = listCopy(result);
+ /*
+ * Safety check: join RTEs should not be SELECT FOR UPDATE targets
+ */
+ if (intMember(j->rtindex, root->rowMarks))
+ elog(ERROR, "SELECT FOR UPDATE cannot be applied to a join");
}
else
- elog(ERROR, "add_missing_rels_to_query: unexpected node type %d",
+ elog(ERROR, "add_base_rels_to_query: unexpected node type %d",
nodeTag(jtnode));
return result;
}
+/*****************************************************************************
+ *
+ * TARGET LISTS
+ *
+ *****************************************************************************/
+
+/*
+ * build_base_rel_tlists
+ * Creates targetlist entries for each var seen in 'tlist' and adds
+ * them to the tlist of the appropriate rel node.
+ */
+void
+build_base_rel_tlists(Query *root, List *tlist)
+{
+ List *tlist_vars = pull_var_clause((Node *) tlist, false);
+
+ add_vars_to_targetlist(root, tlist_vars);
+ freeList(tlist_vars);
+}
+
+/*
+ * add_vars_to_targetlist
+ * For each variable appearing in the list, add it to the owning
+ * relation's targetlist if not already present.
+ *
+ * Note that join alias variables will be attached to the otherrel for
+ * the join RTE. They will later be transferred to the tlist of
+ * the corresponding joinrel. We will also cause entries to be made
+ * for the Vars that the alias will eventually depend on.
+ */
+static void
+add_vars_to_targetlist(Query *root, List *vars)
+{
+ List *temp;
+
+ foreach(temp, vars)
+ {
+ Var *var = (Var *) lfirst(temp);
+ RelOptInfo *rel = find_base_rel(root, var->varno);
+
+ add_var_to_tlist(rel, var);
+
+ if (rel->reloptkind == RELOPT_OTHER_JOIN_REL)
+ {
+ /* Var is an alias */
+ Var *leftsubvar,
+ *rightsubvar;
+
+ build_join_alias_subvars(root, var,
+ &leftsubvar, &rightsubvar);
+
+ rel = find_base_rel(root, leftsubvar->varno);
+ add_var_to_tlist(rel, leftsubvar);
+ rel = find_base_rel(root, rightsubvar->varno);
+ add_var_to_tlist(rel, rightsubvar);
+ }
+ }
+}
+
+
/*****************************************************************************
*
* QUALIFICATIONS
* distribute_quals_to_rels
* Recursively scan the query's join tree for WHERE and JOIN/ON qual
* clauses, and add these to the appropriate RestrictInfo and JoinInfo
- * lists belonging to base RelOptInfos. New base rel entries are created
- * as needed. Also, base RelOptInfos are marked with outerjoinset
- * information, to aid in proper positioning of qual clauses that appear
- * above outer joins.
+ * lists belonging to base RelOptInfos. Also, base RelOptInfos are marked
+ * with outerjoinset information, to aid in proper positioning of qual
+ * clauses that appear above outer joins.
*
* NOTE: when dealing with inner joins, it is appropriate to let a qual clause
* be evaluated at the lowest level where all the variables it mentions are
* a rel, thereby forcing them up the join tree to the right level.
*
* To ease the calculation of these values, distribute_quals_to_rels() returns
- * the list of Relids involved in its own level of join. This is just an
+ * the list of base Relids involved in its own level of join. This is just an
* internal convenience; no outside callers pay attention to the result.
*/
Relids
foreach(relid, rels)
{
int relno = lfirsti(relid);
- RelOptInfo *rel = build_base_rel(root, relno);
+ RelOptInfo *rel = find_base_rel(root, relno);
/*
* Since we do this bottom-up, any outer-rels previously marked
clause_get_relids_vars(clause, &relids, &vars);
/*
- * Cross-check: clause should contain no relids not within its scope.
- * Otherwise the parser messed up.
+ * The clause might contain some join alias vars; if so, we want to
+ * remove the join otherrelids from relids and add the referent joins'
+ * scope lists instead (thus ensuring that the clause can be evaluated
+ * no lower than that join node). We rely here on the marking done
+ * earlier by add_base_rels_to_query.
+ *
+ * We can combine this step with a cross-check that the clause contains
+ * no relids not within its scope. If the first crosscheck succeeds,
+ * the clause contains no aliases and we needn't look more closely.
*/
if (!is_subseti(relids, qualscope))
- elog(ERROR, "JOIN qualification may not refer to other relations");
+ {
+ Relids newrelids = NIL;
+ List *relid;
+
+ foreach(relid, relids)
+ {
+ RelOptInfo *rel = find_other_rel(root, lfirsti(relid));
+
+ if (rel && rel->outerjoinset)
+ {
+ /* this relid is for a join RTE */
+ newrelids = set_unioni(newrelids, rel->outerjoinset);
+ }
+ else
+ {
+ /* this relid is for a true baserel */
+ newrelids = lappendi(newrelids, lfirsti(relid));
+ }
+ }
+ relids = newrelids;
+ /* Now repeat the crosscheck */
+ if (!is_subseti(relids, qualscope))
+ elog(ERROR, "JOIN qualification may not refer to other relations");
+ }
/*
* If the clause is variable-free, we force it to be evaluated at its
can_be_equijoin = true;
foreach(relid, relids)
{
- RelOptInfo *rel = build_base_rel(root, lfirsti(relid));
+ RelOptInfo *rel = find_base_rel(root, lfirsti(relid));
if (rel->outerjoinset &&
!is_subseti(rel->outerjoinset, relids))
* There is only one relation participating in 'clause', so
* 'clause' is a restriction clause for that relation.
*/
- RelOptInfo *rel = build_base_rel(root, lfirsti(relids));
+ RelOptInfo *rel = find_base_rel(root, lfirsti(relids));
/*
* Check for a "mergejoinable" clause even though it's not a join
* Find or make the joininfo node for this combination of rels,
* and add the restrictinfo node to it.
*/
- joininfo = find_joininfo_node(build_base_rel(root, cur_relid),
+ joininfo = find_joininfo_node(find_base_rel(root, cur_relid),
unjoined_relids);
joininfo->jinfo_restrictinfo = lappend(joininfo->jinfo_restrictinfo,
restrictinfo);
* If both vars belong to same rel, we need to look at that rel's
* baserestrictinfo list. If different rels, each will have a
* joininfo node for the other, and we can scan either list.
- *
- * All baserel entries should already exist at this point, so use
- * find_base_rel not build_base_rel.
*/
rel1 = find_base_rel(root, irel1);
if (irel1 == irel2)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.67 2001/10/25 05:49:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.68 2002/03/12 00:51:46 tgl Exp $
*
*-------------------------------------------------------------------------
*/
List *flat_tlist,
double tuple_fraction)
{
- List *joined_rels;
- List *brel;
RelOptInfo *final_rel;
Plan *resultplan;
Path *cheapestpath;
Path *presortedpath;
- /*
- * Examine the targetlist and qualifications, adding entries to
- * base_rel_list as relation references are found (e.g., in the
- * qualification, the targetlist, etc.). Restrict and join clauses
- * are added to appropriate lists belonging to the mentioned
- * relations. We also build lists of equijoined keys for pathkey
- * construction.
- */
+ /* init lists to empty */
root->base_rel_list = NIL;
root->other_rel_list = NIL;
root->join_rel_list = NIL;
root->equi_key_list = NIL;
- build_base_rel_tlists(root, flat_tlist);
-
- (void) distribute_quals_to_rels(root, (Node *) root->jointree);
-
/*
- * Make sure we have RelOptInfo nodes for all relations to be joined.
+ * Construct RelOptInfo nodes for all base relations in query.
*/
- joined_rels = add_missing_rels_to_query(root, (Node *) root->jointree);
+ (void) add_base_rels_to_query(root, (Node *) root->jointree);
/*
- * Check that the join tree includes all the base relations used in
- * the query --- otherwise, the parser or rewriter messed up.
+ * Examine the targetlist and qualifications, adding entries to
+ * baserel targetlists for all referenced Vars. Restrict and join
+ * clauses are added to appropriate lists belonging to the mentioned
+ * relations. We also build lists of equijoined keys for pathkey
+ * construction.
*/
- foreach(brel, root->base_rel_list)
- {
- RelOptInfo *baserel = (RelOptInfo *) lfirst(brel);
- int relid = lfirsti(baserel->relids);
+ build_base_rel_tlists(root, flat_tlist);
- if (!ptrMember(baserel, joined_rels))
- elog(ERROR, "Internal error: no jointree entry for rel %s (%d)",
- rt_fetch(relid, root->rtable)->eref->relname, relid);
- }
+ (void) distribute_quals_to_rels(root, (Node *) root->jointree);
/*
* Use the completed lists of equijoined keys to deduce any implied
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.114 2001/12/10 22:54:12 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.115 2002/03/12 00:51:47 tgl Exp $
*
*-------------------------------------------------------------------------
*/
result_plan->nParamExec = length(PlannerParamVar);
/* final cleanup of the plan */
- set_plan_references(result_plan);
+ set_plan_references(parse, result_plan);
/* restore state for outer planner, if any */
PlannerQueryLevel = save_PlannerQueryLevel;
static Node *
preprocess_expression(Query *parse, Node *expr, int kind)
{
+ bool has_join_rtes;
+ List *rt;
+
/*
* Simplify constant expressions.
*
if (PlannerQueryLevel > 1)
expr = SS_replace_correlation_vars(expr);
+ /*
+ * If the query has any join RTEs, try to replace join alias variables
+ * with base-relation variables, to allow quals to be pushed down.
+ * We must do this after sublink processing, since it does not recurse
+ * into sublinks.
+ *
+ * The flattening pass is expensive enough that it seems worthwhile to
+ * scan the rangetable to see if we can avoid it.
+ */
+ has_join_rtes = false;
+ foreach(rt, parse->rtable)
+ {
+ RangeTblEntry *rte = lfirst(rt);
+
+ if (rte->rtekind == RTE_JOIN)
+ {
+ has_join_rtes = true;
+ break;
+ }
+ }
+ if (has_join_rtes)
+ expr = flatten_join_alias_vars(expr, parse, 0);
+
return expr;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.73 2001/11/05 17:46:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.74 2002/03/12 00:51:48 tgl Exp $
*
*-------------------------------------------------------------------------
*/
-#include <sys/types.h>
-
#include "postgres.h"
+#include <sys/types.h>
+
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/clauses.h"
#include "optimizer/planmain.h"
#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+
typedef struct
{
+ Query *root;
List *outer_tlist;
List *inner_tlist;
Index acceptable_rel;
+ Index join_rti;
} join_references_context;
typedef struct
} replace_vars_with_subplan_refs_context;
static void fix_expr_references(Plan *plan, Node *node);
-static void set_join_references(Join *join);
+static void set_join_references(Query *root, Join *join);
static void set_uppernode_references(Plan *plan, Index subvarno);
static Node *join_references_mutator(Node *node,
join_references_context *context);
* Returns nothing of interest, but modifies internal fields of nodes.
*/
void
-set_plan_references(Plan *plan)
+set_plan_references(Query *root, Plan *plan)
{
List *pl;
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
/* Recurse into subplan too */
- set_plan_references(((SubqueryScan *) plan)->subplan);
+ set_plan_references(root, ((SubqueryScan *) plan)->subplan);
break;
case T_NestLoop:
- set_join_references((Join *) plan);
+ set_join_references(root, (Join *) plan);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
fix_expr_references(plan, (Node *) ((Join *) plan)->joinqual);
break;
case T_MergeJoin:
- set_join_references((Join *) plan);
+ set_join_references(root, (Join *) plan);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
fix_expr_references(plan, (Node *) ((Join *) plan)->joinqual);
(Node *) ((MergeJoin *) plan)->mergeclauses);
break;
case T_HashJoin:
- set_join_references((Join *) plan);
+ set_join_references(root, (Join *) plan);
fix_expr_references(plan, (Node *) plan->targetlist);
fix_expr_references(plan, (Node *) plan->qual);
fix_expr_references(plan, (Node *) ((Join *) plan)->joinqual);
* recurse into subplans.
*/
foreach(pl, ((Append *) plan)->appendplans)
- set_plan_references((Plan *) lfirst(pl));
+ set_plan_references(root, (Plan *) lfirst(pl));
break;
default:
elog(ERROR, "set_plan_references: unknown plan type %d",
* plan's var nodes against the already-modified nodes of the
* subplans.
*/
- set_plan_references(plan->lefttree);
- set_plan_references(plan->righttree);
+ set_plan_references(root, plan->lefttree);
+ set_plan_references(root, plan->righttree);
foreach(pl, plan->initPlan)
{
SubPlan *sp = (SubPlan *) lfirst(pl);
Assert(IsA(sp, SubPlan));
- set_plan_references(sp->plan);
+ set_plan_references(root, sp->plan);
}
foreach(pl, plan->subPlan)
{
SubPlan *sp = (SubPlan *) lfirst(pl);
Assert(IsA(sp, SubPlan));
- set_plan_references(sp->plan);
+ set_plan_references(root, sp->plan);
}
}
* 'join' is a join plan node
*/
static void
-set_join_references(Join *join)
+set_join_references(Query *root, Join *join)
{
Plan *outer = join->plan.lefttree;
Plan *inner = join->plan.righttree;
List *inner_tlist = ((inner == NULL) ? NIL : inner->targetlist);
join->plan.targetlist = join_references(join->plan.targetlist,
+ root,
outer_tlist,
inner_tlist,
- (Index) 0);
+ (Index) 0,
+ join->joinrti);
}
/*
* Creates a new set of targetlist entries or join qual clauses by
* changing the varno/varattno values of variables in the clauses
* to reference target list values from the outer and inner join
- * relation target lists.
+ * relation target lists. Also, any join alias variables in the
+ * clauses are expanded into references to their component variables.
*
* This is used in two different scenarios: a normal join clause, where
* all the Vars in the clause *must* be replaced by OUTER or INNER references;
* 'inner_tlist' is the target list of the inner join relation, or NIL
* 'acceptable_rel' is either zero or the rangetable index of a relation
* whose Vars may appear in the clause without provoking an error.
+ * 'join_rti' is either zero or the join RTE index of join alias variables
+ * that should be expanded.
*
* Returns the new expression tree. The original clause structure is
* not modified.
*/
List *
join_references(List *clauses,
+ Query *root,
List *outer_tlist,
List *inner_tlist,
- Index acceptable_rel)
+ Index acceptable_rel,
+ Index join_rti)
{
join_references_context context;
+ context.root = root;
context.outer_tlist = outer_tlist;
context.inner_tlist = inner_tlist;
context.acceptable_rel = acceptable_rel;
+ context.join_rti = join_rti;
return (List *) join_references_mutator((Node *) clauses, &context);
}
if (IsA(node, Var))
{
Var *var = (Var *) node;
- Var *newvar = (Var *) copyObject(var);
Resdom *resdom;
+ /* First look for the var in the input tlists */
resdom = tlist_member((Node *) var, context->outer_tlist);
if (resdom)
{
+ Var *newvar = (Var *) copyObject(var);
+
newvar->varno = OUTER;
newvar->varattno = resdom->resno;
return (Node *) newvar;
resdom = tlist_member((Node *) var, context->inner_tlist);
if (resdom)
{
+ Var *newvar = (Var *) copyObject(var);
+
newvar->varno = INNER;
newvar->varattno = resdom->resno;
return (Node *) newvar;
}
+ /* Perhaps it's a join alias that can be resolved to input vars? */
+ if (var->varno == context->join_rti)
+ {
+ Node *newnode;
+
+ newnode = flatten_join_alias_vars((Node *) var,
+ context->root,
+ context->join_rti);
+ /* Must now resolve the input vars... */
+ newnode = join_references_mutator(newnode, context);
+ return newnode;
+ }
+
/*
- * Var not in either tlist --- either raise an error, or return
- * the Var unmodified.
+ * No referent found for Var --- either raise an error, or return
+ * the Var unmodified if it's for acceptable_rel.
*/
if (var->varno != context->acceptable_rel)
elog(ERROR, "join_references: variable not in subplan target lists");
- return (Node *) newvar;
+ return (Node *) copyObject(var);
}
return expression_tree_mutator(node,
join_references_mutator,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.71 2002/03/05 05:10:24 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.72 2002/03/12 00:51:49 tgl Exp $
*
*-------------------------------------------------------------------------
*/
expand_inherted_rtentry(Query *parse, Index rti, bool dup_parent)
{
RangeTblEntry *rte = rt_fetch(rti, parse->rtable);
- Oid parentOID = rte->relid;
+ Oid parentOID;
List *inhOIDs;
List *inhRTIs;
List *l;
/* Does RT entry allow inheritance? */
if (!rte->inh)
return NIL;
- Assert(parentOID != InvalidOid && rte->subquery == NULL);
+ Assert(rte->rtekind == RTE_RELATION);
/* Always clear the parent's inh flag, see above comments */
rte->inh = false;
/* Fast path for common case of childless table */
+ parentOID = rte->relid;
if (!has_subclass(parentOID))
return NIL;
/* Scan for all members of inheritance set */
rtr->rtindex = context->new_rt_index;
return (Node *) rtr;
}
+ if (IsA(node, JoinExpr))
+ {
+ /* Copy the JoinExpr node with correct mutation of subnodes */
+ JoinExpr *j;
+
+ j = (JoinExpr *) expression_tree_mutator(node,
+ adjust_inherited_attrs_mutator,
+ (void *) context);
+ /* now fix JoinExpr's rtindex */
+ if (j->rtindex == context->old_rt_index)
+ j->rtindex = context->new_rt_index;
+ return (Node *) j;
+ }
/*
* We have to process RestrictInfo nodes specially: we do NOT want to
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.93 2002/01/03 18:01:59 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.94 2002/03/12 00:51:50 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
return true;
if (walker(join->quals, context))
return true;
- if (walker((Node *) join->colvars, context))
- return true;
-
/*
- * alias clause, using list, colnames list are deemed
- * uninteresting.
+ * alias clause, using list are deemed uninteresting.
*/
}
break;
MUTATE(newnode->larg, join->larg, Node *);
MUTATE(newnode->rarg, join->rarg, Node *);
MUTATE(newnode->quals, join->quals, Node *);
- MUTATE(newnode->colvars, join->colvars, List *);
- /* We do not mutate alias, using, or colnames by default */
+ /* We do not mutate alias or using by default */
return (Node *) newnode;
}
break;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.35 2001/10/25 05:49:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.36 2002/03/12 00:51:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* build_base_rel
- * Returns relation entry corresponding to 'relid', creating a new one
- * if necessary. This is for base relations.
+ * Construct a new base relation RelOptInfo, and put it in the query's
+ * base_rel_list.
*/
-RelOptInfo *
+void
build_base_rel(Query *root, int relid)
{
List *rels;
RelOptInfo *rel;
- /* Already made? */
+ /* Rel should not exist already */
foreach(rels, root->base_rel_list)
{
rel = (RelOptInfo *) lfirst(rels);
/* length(rel->relids) == 1 for all members of base_rel_list */
if (lfirsti(rel->relids) == relid)
- return rel;
+ elog(ERROR, "build_base_rel: rel already exists");
}
- /* It should not exist as an "other" rel */
+ /* It should not exist as an "other" rel, either */
foreach(rels, root->other_rel_list)
{
rel = (RelOptInfo *) lfirst(rels);
/* and add it to the list */
root->base_rel_list = lcons(rel, root->base_rel_list);
-
- return rel;
}
/*
* build_other_rel
* Returns relation entry corresponding to 'relid', creating a new one
- * if necessary. This is for 'other' relations, which are just like
+ * if necessary. This is for 'other' relations, which are much like
* base relations except that they live in a different list.
*/
RelOptInfo *
/* No existing RelOptInfo for this other rel, so make a new one */
rel = make_base_rel(root, relid);
+ /* if it's not a join rel, must be a child rel */
+ if (rel->reloptkind == RELOPT_BASEREL)
+ rel->reloptkind = RELOPT_OTHER_CHILD_REL;
+
/* and add it to the list */
root->other_rel_list = lcons(rel, root->other_rel_list);
make_base_rel(Query *root, int relid)
{
RelOptInfo *rel = makeNode(RelOptInfo);
- Oid relationObjectId;
+ RangeTblEntry *rte = rt_fetch(relid, root->rtable);
+ rel->reloptkind = RELOPT_BASEREL;
rel->relids = makeListi1(relid);
rel->rows = 0;
rel->width = 0;
rel->pages = 0;
rel->tuples = 0;
rel->subplan = NULL;
+ rel->joinrti = 0;
+ rel->joinrteids = NIL;
rel->baserestrictinfo = NIL;
rel->baserestrictcost = 0;
rel->outerjoinset = NIL;
rel->joininfo = NIL;
rel->innerjoin = NIL;
- /* Check rtable to see if it's a plain relation or a subquery */
- relationObjectId = getrelid(relid, root->rtable);
-
- if (relationObjectId != InvalidOid)
- {
- /* Plain relation --- retrieve statistics from the system catalogs */
- bool indexed;
-
- get_relation_info(relationObjectId,
- &indexed, &rel->pages, &rel->tuples);
- if (indexed)
- rel->indexlist = find_secondary_indexes(relationObjectId);
- }
- else
+ /* Check type of rtable entry */
+ switch (rte->rtekind)
{
- /* subquery --- mark it as such for later processing */
- rel->issubquery = true;
+ case RTE_RELATION:
+ {
+ /* Table --- retrieve statistics from the system catalogs */
+ bool indexed;
+
+ get_relation_info(rte->relid,
+ &indexed, &rel->pages, &rel->tuples);
+ if (indexed)
+ rel->indexlist = find_secondary_indexes(rte->relid);
+ break;
+ }
+ case RTE_SUBQUERY:
+ /* Subquery --- mark it as such for later processing */
+ rel->issubquery = true;
+ break;
+ case RTE_JOIN:
+ /* Join --- must be an otherrel */
+ rel->reloptkind = RELOPT_OTHER_JOIN_REL;
+ break;
+ default:
+ elog(ERROR, "make_base_rel: unsupported RTE kind %d",
+ (int) rte->rtekind);
+ break;
}
return rel;
return NULL; /* keep compiler quiet */
}
+/*
+ * find_other_rel
+ * Find an otherrel entry, if one exists for the given relid.
+ * Return NULL if no entry.
+ */
+RelOptInfo *
+find_other_rel(Query *root, int relid)
+{
+ List *rels;
+
+ foreach(rels, root->other_rel_list)
+ {
+ RelOptInfo *rel = (RelOptInfo *) lfirst(rels);
+
+ if (lfirsti(rel->relids) == relid)
+ return rel;
+ }
+ return NULL;
+}
+
+/*
+ * find_other_rel_for_join
+ * Look for an otherrel for a join RTE matching the given baserel set.
+ * Return NULL if no entry.
+ */
+RelOptInfo *
+find_other_rel_for_join(Query *root, List *relids)
+{
+ List *rels;
+
+ foreach(rels, root->other_rel_list)
+ {
+ RelOptInfo *rel = (RelOptInfo *) lfirst(rels);
+
+ if (rel->reloptkind == RELOPT_OTHER_JOIN_REL
+ && sameseti(relids, rel->outerjoinset))
+ return rel;
+ }
+ return NULL;
+}
+
/*
* find_join_rel
* Returns relation entry corresponding to 'relids' (a list of RT indexes),
{
List *joinrelids;
RelOptInfo *joinrel;
+ RelOptInfo *joinrterel;
List *restrictlist;
List *new_outer_tlist;
List *new_inner_tlist;
* Nope, so make one.
*/
joinrel = makeNode(RelOptInfo);
+ joinrel->reloptkind = RELOPT_JOINREL;
joinrel->relids = joinrelids;
joinrel->rows = 0;
joinrel->width = 0;
joinrel->pages = 0;
joinrel->tuples = 0;
joinrel->subplan = NULL;
+ joinrel->joinrti = 0;
+ joinrel->joinrteids = nconc(listCopy(outer_rel->joinrteids),
+ inner_rel->joinrteids);
joinrel->baserestrictinfo = NIL;
joinrel->baserestrictcost = 0;
joinrel->outerjoinset = NIL;
joinrel->joininfo = NIL;
joinrel->innerjoin = NIL;
+ /* Is there a join RTE matching this join? */
+ joinrterel = find_other_rel_for_join(root, joinrelids);
+ if (joinrterel)
+ {
+ /* Yes, remember its RT index */
+ joinrel->joinrti = lfirsti(joinrterel->relids);
+ joinrel->joinrteids = lconsi(joinrel->joinrti, joinrel->joinrteids);
+ }
+
/*
* Create a new tlist by removing irrelevant elements from both tlists
* of the outer and inner join relations and then merging the results
* together.
*
+ * XXX right now we don't remove any irrelevant elements, we just
+ * append the two tlists together. Someday consider pruning vars from the
+ * join's targetlist if they are needed only to evaluate restriction
+ * clauses of this join, and will never be accessed at higher levels of
+ * the plantree.
+ *
* NOTE: the tlist order for a join rel will depend on which pair of
* outer and inner rels we first try to build it from. But the
* contents should be the same regardless.
- *
- * XXX someday: consider pruning vars from the join's targetlist if they
- * are needed only to evaluate restriction clauses of this join, and
- * will never be accessed at higher levels of the plantree.
*/
new_outer_tlist = new_join_tlist(outer_rel->targetlist, 1);
new_inner_tlist = new_join_tlist(inner_rel->targetlist,
length(new_outer_tlist) + 1);
joinrel->targetlist = nconc(new_outer_tlist, new_inner_tlist);
+ /*
+ * If there are any alias variables attached to the matching join RTE,
+ * attach them to the tlist too, so that they will be evaluated for use
+ * at higher plan levels.
+ */
+ if (joinrterel)
+ {
+ List *jrtetl;
+
+ foreach(jrtetl, joinrterel->targetlist)
+ {
+ TargetEntry *jrtete = lfirst(jrtetl);
+
+ add_var_to_tlist(joinrel, (Var *) jrtete->expr);
+ }
+ }
+
/*
* Construct restrict and join clause lists for the new joinrel. (The
* caller might or might not need the restrictlist, but I need it
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.33 2001/10/25 05:49:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.34 2002/03/12 00:51:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+#include "nodes/makefuncs.h"
#include "nodes/plannodes.h"
#include "optimizer/clauses.h"
#include "optimizer/var.h"
+#include "parser/parsetree.h"
+#include "parser/parse_coerce.h"
typedef struct
bool includeUpperVars;
} pull_var_clause_context;
+typedef struct
+{
+ Query *root;
+ int expandRTI;
+} flatten_join_alias_vars_context;
+
static bool pull_varnos_walker(Node *node,
pull_varnos_context *context);
static bool contain_var_reference_walker(Node *node,
static bool contain_var_clause_walker(Node *node, void *context);
static bool pull_var_clause_walker(Node *node,
pull_var_clause_context *context);
+static Node *flatten_join_alias_vars_mutator(Node *node,
+ flatten_join_alias_vars_context *context);
+static Node *flatten_join_alias_var(Var *var, Query *root, int expandRTI);
+static Node *find_jointree_item(Node *jtnode, int rtindex);
/*
return expression_tree_walker(node, pull_var_clause_walker,
(void *) context);
}
+
+
+/*
+ * flatten_join_alias_vars
+ * Whereever possible, replace Vars that reference JOIN outputs with
+ * references to the original relation variables instead. This allows
+ * quals involving such vars to be pushed down. Vars that cannot be
+ * simplified to non-join Vars are replaced by COALESCE expressions
+ * if they have varno = expandRTI, and are left as JOIN RTE references
+ * otherwise. (Pass expandRTI = 0 to prevent all COALESCE expansion.)
+ *
+ * Upper-level vars (with varlevelsup > 0) are ignored; normally there
+ * should not be any by the time this routine is called.
+ *
+ * Does not examine subqueries, therefore must only be used after reduction
+ * of sublinks to subplans!
+ */
+Node *
+flatten_join_alias_vars(Node *node, Query *root, int expandRTI)
+{
+ flatten_join_alias_vars_context context;
+
+ context.root = root;
+ context.expandRTI = expandRTI;
+
+ return flatten_join_alias_vars_mutator(node, &context);
+}
+
+static Node *
+flatten_join_alias_vars_mutator(Node *node,
+ flatten_join_alias_vars_context *context)
+{
+ if (node == NULL)
+ return NULL;
+ if (IsA(node, Var))
+ {
+ Var *var = (Var *) node;
+
+ if (var->varlevelsup != 0)
+ return node; /* no need to copy, really */
+ return flatten_join_alias_var(var, context->root, context->expandRTI);
+ }
+ return expression_tree_mutator(node, flatten_join_alias_vars_mutator,
+ (void *) context);
+}
+
+static Node *
+flatten_join_alias_var(Var *var, Query *root, int expandRTI)
+{
+ Index varno = var->varno;
+ AttrNumber varattno = var->varattno;
+ Oid vartype = var->vartype;
+ int32 vartypmod = var->vartypmod;
+ JoinExpr *jexpr = NULL;
+
+ /*
+ * Loop to cope with joins of joins
+ */
+ for (;;)
+ {
+ RangeTblEntry *rte = rt_fetch(varno, root->rtable);
+ Index leftrti,
+ rightrti;
+ AttrNumber leftattno,
+ rightattno;
+ RangeTblEntry *subrte;
+ Oid subtype;
+ int32 subtypmod;
+
+ if (rte->rtekind != RTE_JOIN)
+ break; /* reached a non-join RTE */
+ /*
+ * Find the RT indexes of the left and right children of the
+ * join node. We have to search the join tree to do this,
+ * which is a major pain in the neck --- but keeping RT indexes
+ * in other RT entries is worse, because it makes modifying
+ * querytrees difficult. (Perhaps we can improve on the
+ * rangetable/jointree datastructure someday.) One thing we
+ * can do is avoid repeated searches while tracing a single
+ * variable down to its baserel.
+ */
+ if (jexpr == NULL)
+ jexpr = (JoinExpr *)
+ find_jointree_item((Node *) root->jointree, varno);
+ if (jexpr == NULL ||
+ !IsA(jexpr, JoinExpr) ||
+ jexpr->rtindex != varno)
+ elog(ERROR, "flatten_join_alias_var: failed to find JoinExpr");
+ if (IsA(jexpr->larg, RangeTblRef))
+ leftrti = ((RangeTblRef *) jexpr->larg)->rtindex;
+ else if (IsA(jexpr->larg, JoinExpr))
+ leftrti = ((JoinExpr *) jexpr->larg)->rtindex;
+ else
+ {
+ elog(ERROR, "flatten_join_alias_var: unexpected subtree type");
+ leftrti = 0; /* keep compiler quiet */
+ }
+ if (IsA(jexpr->rarg, RangeTblRef))
+ rightrti = ((RangeTblRef *) jexpr->rarg)->rtindex;
+ else if (IsA(jexpr->rarg, JoinExpr))
+ rightrti = ((JoinExpr *) jexpr->rarg)->rtindex;
+ else
+ {
+ elog(ERROR, "flatten_join_alias_var: unexpected subtree type");
+ rightrti = 0; /* keep compiler quiet */
+ }
+ /*
+ * See if the join var is from the left side, the right side,
+ * or both (ie, it is a USING/NATURAL JOIN merger column).
+ */
+ Assert(varattno > 0);
+ leftattno = (AttrNumber) nthi(varattno-1, rte->joinleftcols);
+ rightattno = (AttrNumber) nthi(varattno-1, rte->joinrightcols);
+ if (leftattno && rightattno)
+ {
+ /*
+ * Var is a merge var. If a left or right join, we can replace
+ * it by the left or right input var respectively; we only need
+ * a COALESCE for a full join. However, beware of the possibility
+ * that there's been a type promotion to make the input vars
+ * compatible; do not replace a var by one of a different type!
+ */
+ if (rte->jointype == JOIN_INNER ||
+ rte->jointype == JOIN_LEFT)
+ {
+ subrte = rt_fetch(leftrti, root->rtable);
+ get_rte_attribute_type(subrte, leftattno,
+ &subtype, &subtypmod);
+ if (vartype == subtype && vartypmod == subtypmod)
+ {
+ varno = leftrti;
+ varattno = leftattno;
+ jexpr = (JoinExpr *) jexpr->larg;
+ continue;
+ }
+ }
+ if (rte->jointype == JOIN_INNER ||
+ rte->jointype == JOIN_RIGHT)
+ {
+ subrte = rt_fetch(rightrti, root->rtable);
+ get_rte_attribute_type(subrte, rightattno,
+ &subtype, &subtypmod);
+ if (vartype == subtype && vartypmod == subtypmod)
+ {
+ varno = rightrti;
+ varattno = rightattno;
+ jexpr = (JoinExpr *) jexpr->rarg;
+ continue;
+ }
+ }
+ /*
+ * This var cannot be substituted directly, only with a COALESCE.
+ * Do so only if it belongs to the particular join indicated by
+ * the caller.
+ */
+ if (varno != expandRTI)
+ break;
+ {
+ Node *l_var,
+ *r_var;
+ CaseExpr *c = makeNode(CaseExpr);
+ CaseWhen *w = makeNode(CaseWhen);
+ NullTest *n = makeNode(NullTest);
+
+ subrte = rt_fetch(leftrti, root->rtable);
+ get_rte_attribute_type(subrte, leftattno,
+ &subtype, &subtypmod);
+ l_var = (Node *) makeVar(leftrti,
+ leftattno,
+ subtype,
+ subtypmod,
+ 0);
+ if (subtype != vartype)
+ {
+ l_var = coerce_type(NULL, l_var, subtype,
+ vartype, vartypmod);
+ l_var = coerce_type_typmod(NULL, l_var,
+ vartype, vartypmod);
+ }
+ else if (subtypmod != vartypmod)
+ l_var = coerce_type_typmod(NULL, l_var,
+ vartype, vartypmod);
+
+ subrte = rt_fetch(rightrti, root->rtable);
+ get_rte_attribute_type(subrte, rightattno,
+ &subtype, &subtypmod);
+ r_var = (Node *) makeVar(rightrti,
+ rightattno,
+ subtype,
+ subtypmod,
+ 0);
+ if (subtype != vartype)
+ {
+ r_var = coerce_type(NULL, r_var, subtype,
+ vartype, vartypmod);
+ r_var = coerce_type_typmod(NULL, r_var,
+ vartype, vartypmod);
+ }
+ else if (subtypmod != vartypmod)
+ r_var = coerce_type_typmod(NULL, r_var,
+ vartype, vartypmod);
+
+ n->arg = l_var;
+ n->nulltesttype = IS_NOT_NULL;
+ w->expr = (Node *) n;
+ w->result = l_var;
+ c->casetype = vartype;
+ c->args = makeList1(w);
+ c->defresult = r_var;
+ return (Node *) c;
+ }
+ }
+ else if (leftattno)
+ {
+ /* Here we do not need to check the type */
+ varno = leftrti;
+ varattno = leftattno;
+ jexpr = (JoinExpr *) jexpr->larg;
+ }
+ else
+ {
+ Assert(rightattno);
+ /* Here we do not need to check the type */
+ varno = rightrti;
+ varattno = rightattno;
+ jexpr = (JoinExpr *) jexpr->rarg;
+ }
+ }
+
+ /*
+ * When we fall out of the loop, we've reached the base Var.
+ */
+ return (Node *) makeVar(varno,
+ varattno,
+ vartype,
+ vartypmod,
+ 0);
+}
+
+/*
+ * Given a join alias Var, construct Vars for the two input vars it directly
+ * depends on. Note that this should *only* be called for merger alias Vars.
+ * In practice it is only used for Vars that got past flatten_join_alias_vars.
+ */
+void
+build_join_alias_subvars(Query *root, Var *aliasvar,
+ Var **leftsubvar, Var **rightsubvar)
+{
+ Index varno = aliasvar->varno;
+ AttrNumber varattno = aliasvar->varattno;
+ RangeTblEntry *rte;
+ JoinExpr *jexpr;
+ Index leftrti,
+ rightrti;
+ AttrNumber leftattno,
+ rightattno;
+ RangeTblEntry *subrte;
+ Oid subtype;
+ int32 subtypmod;
+
+ Assert(aliasvar->varlevelsup == 0);
+ rte = rt_fetch(varno, root->rtable);
+ Assert(rte->rtekind == RTE_JOIN);
+
+ /*
+ * Find the RT indexes of the left and right children of the
+ * join node.
+ */
+ jexpr = (JoinExpr *) find_jointree_item((Node *) root->jointree, varno);
+ if (jexpr == NULL ||
+ !IsA(jexpr, JoinExpr) ||
+ jexpr->rtindex != varno)
+ elog(ERROR, "build_join_alias_subvars: failed to find JoinExpr");
+ if (IsA(jexpr->larg, RangeTblRef))
+ leftrti = ((RangeTblRef *) jexpr->larg)->rtindex;
+ else if (IsA(jexpr->larg, JoinExpr))
+ leftrti = ((JoinExpr *) jexpr->larg)->rtindex;
+ else
+ {
+ elog(ERROR, "build_join_alias_subvars: unexpected subtree type");
+ leftrti = 0; /* keep compiler quiet */
+ }
+ if (IsA(jexpr->rarg, RangeTblRef))
+ rightrti = ((RangeTblRef *) jexpr->rarg)->rtindex;
+ else if (IsA(jexpr->rarg, JoinExpr))
+ rightrti = ((JoinExpr *) jexpr->rarg)->rtindex;
+ else
+ {
+ elog(ERROR, "build_join_alias_subvars: unexpected subtree type");
+ rightrti = 0; /* keep compiler quiet */
+ }
+
+ Assert(varattno > 0);
+ leftattno = (AttrNumber) nthi(varattno-1, rte->joinleftcols);
+ rightattno = (AttrNumber) nthi(varattno-1, rte->joinrightcols);
+ if (!(leftattno && rightattno))
+ elog(ERROR, "build_join_alias_subvars: non-merger variable");
+
+ subrte = rt_fetch(leftrti, root->rtable);
+ get_rte_attribute_type(subrte, leftattno,
+ &subtype, &subtypmod);
+ *leftsubvar = makeVar(leftrti,
+ leftattno,
+ subtype,
+ subtypmod,
+ 0);
+
+ subrte = rt_fetch(rightrti, root->rtable);
+ get_rte_attribute_type(subrte, rightattno,
+ &subtype, &subtypmod);
+ *rightsubvar = makeVar(rightrti,
+ rightattno,
+ subtype,
+ subtypmod,
+ 0);
+}
+
+/*
+ * Find jointree item matching the specified RT index
+ */
+static Node *
+find_jointree_item(Node *jtnode, int rtindex)
+{
+ if (jtnode == NULL)
+ return NULL;
+ if (IsA(jtnode, RangeTblRef))
+ {
+ if (((RangeTblRef *) jtnode)->rtindex == rtindex)
+ return jtnode;
+ }
+ else if (IsA(jtnode, FromExpr))
+ {
+ FromExpr *f = (FromExpr *) jtnode;
+ List *l;
+
+ foreach(l, f->fromlist)
+ {
+ jtnode = find_jointree_item(lfirst(l), rtindex);
+ if (jtnode)
+ return jtnode;
+ }
+ }
+ else if (IsA(jtnode, JoinExpr))
+ {
+ JoinExpr *j = (JoinExpr *) jtnode;
+
+ if (j->rtindex == rtindex)
+ return jtnode;
+ jtnode = find_jointree_item(j->larg, rtindex);
+ if (jtnode)
+ return jtnode;
+ jtnode = find_jointree_item(j->rarg, rtindex);
+ if (jtnode)
+ return jtnode;
+ }
+ else
+ elog(ERROR, "find_jointree_item: unexpected node type %d",
+ nodeTag(jtnode));
+ return NULL;
+}
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.219 2002/03/10 06:02:23 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.220 2002/03/12 00:51:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Node *node;
List *lefttl,
*dtlist,
- *targetvars,
+ *colMods,
*targetnames,
- *sv_namespace;
- JoinExpr *jnode;
+ *sv_namespace,
+ *sv_rtable;
+ RangeTblEntry *jrte;
+ RangeTblRef *jrtr;
int tllen;
qry->commandType = CMD_SELECT;
/*
* Generate dummy targetlist for outer query using column names of
* leftmost select and common datatypes of topmost set operation. Also
- * make lists of the dummy vars and their names for use in parsing
- * ORDER BY.
+ * make a list of the column names for use in parsing ORDER BY.
+ *
+ * XXX colMods is a hack to provide a dummy typmod list below. We
+ * should probably keep track of common typmod instead.
*/
qry->targetList = NIL;
- targetvars = NIL;
targetnames = NIL;
+ colMods = NIL;
lefttl = leftmostQuery->targetList;
foreach(dtlist, sostmt->colTypes)
{
-1,
colName,
false);
- expr = (Node *) makeVar(leftmostRTI,
+ expr = (Node *) makeVar(1,
leftResdom->resno,
colType,
-1,
0);
qry->targetList = lappend(qry->targetList,
makeTargetEntry(resdom, expr));
- targetvars = lappend(targetvars, expr);
targetnames = lappend(targetnames, makeString(colName));
+ colMods = lappendi(colMods, -1);
lefttl = lnext(lefttl);
}
/*
* As a first step towards supporting sort clauses that are
* expressions using the output columns, generate a namespace entry
- * that makes the output columns visible. A JoinExpr node is handy
+ * that makes the output columns visible. A Join RTE node is handy
* for this, since we can easily control the Vars generated upon
* matches.
*
* "ORDER BY upper(foo)" will draw the right error message rather than
* "foo not found".
*/
- jnode = makeNode(JoinExpr);
- jnode->colnames = targetnames;
- jnode->colvars = targetvars;
+ jrte = addRangeTableEntryForJoin(NULL,
+ targetnames,
+ JOIN_INNER,
+ sostmt->colTypes,
+ colMods,
+ NIL,
+ NIL,
+ NULL,
+ true);
+ jrtr = makeNode(RangeTblRef);
+ jrtr->rtindex = 1;
+
+ sv_rtable = pstate->p_rtable;
+ pstate->p_rtable = makeList1(jrte);
sv_namespace = pstate->p_namespace;
- pstate->p_namespace = makeList1(jnode);
+ pstate->p_namespace = makeList1(jrtr);
/*
* For now, we don't support resjunk sort clauses on the output of a
qry->targetList);
pstate->p_namespace = sv_namespace;
+ pstate->p_rtable = sv_rtable;
if (tllen != length(qry->targetList))
elog(ERROR, "ORDER BY on a UNION/INTERSECT/EXCEPT result must be on one of the result columns");
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.83 2001/10/25 05:49:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.84 2002/03/12 00:51:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*res_colnames,
*l_colvars,
*r_colvars,
- *res_colvars;
+ *coltypes,
+ *coltypmods,
+ *leftcolnos,
+ *rightcolnos;
+ Index leftrti,
+ rightrti;
+ RangeTblEntry *rte;
/*
* Recursively process the left and right subtrees
/*
* Extract column name and var lists from both subtrees
+ *
+ * Note: expandRTE returns new lists, safe for me to modify
*/
- if (IsA(j->larg, JoinExpr))
- {
- /* Make a copy of the subtree's lists so we can modify! */
- l_colnames = copyObject(((JoinExpr *) j->larg)->colnames);
- l_colvars = copyObject(((JoinExpr *) j->larg)->colvars);
- }
+ if (IsA(j->larg, RangeTblRef))
+ leftrti = ((RangeTblRef *) j->larg)->rtindex;
+ else if (IsA(j->larg, JoinExpr))
+ leftrti = ((JoinExpr *) j->larg)->rtindex;
else
{
- RangeTblEntry *rte;
-
- Assert(IsA(j->larg, RangeTblRef));
- rte = rt_fetch(((RangeTblRef *) j->larg)->rtindex,
- pstate->p_rtable);
- expandRTE(pstate, rte, &l_colnames, &l_colvars);
- /* expandRTE returns new lists, so no need for copyObject */
- }
- if (IsA(j->rarg, JoinExpr))
- {
- /* Make a copy of the subtree's lists so we can modify! */
- r_colnames = copyObject(((JoinExpr *) j->rarg)->colnames);
- r_colvars = copyObject(((JoinExpr *) j->rarg)->colvars);
+ elog(ERROR, "transformFromClauseItem: unexpected subtree type");
+ leftrti = 0; /* keep compiler quiet */
}
+ rte = rt_fetch(leftrti, pstate->p_rtable);
+ expandRTE(pstate, rte, &l_colnames, &l_colvars);
+
+ if (IsA(j->rarg, RangeTblRef))
+ rightrti = ((RangeTblRef *) j->rarg)->rtindex;
+ else if (IsA(j->rarg, JoinExpr))
+ rightrti = ((JoinExpr *) j->rarg)->rtindex;
else
{
- RangeTblEntry *rte;
-
- Assert(IsA(j->rarg, RangeTblRef));
- rte = rt_fetch(((RangeTblRef *) j->rarg)->rtindex,
- pstate->p_rtable);
- expandRTE(pstate, rte, &r_colnames, &r_colvars);
- /* expandRTE returns new lists, so no need for copyObject */
+ elog(ERROR, "transformFromClauseItem: unexpected subtree type");
+ rightrti = 0; /* keep compiler quiet */
}
+ rte = rt_fetch(rightrti, pstate->p_rtable);
+ expandRTE(pstate, rte, &r_colnames, &r_colvars);
/*
* Natural join does not explicitly specify columns; must generate
* Now transform the join qualifications, if any.
*/
res_colnames = NIL;
- res_colvars = NIL;
+ coltypes = NIL;
+ coltypmods = NIL;
+ leftcolnos = NIL;
+ rightcolnos = NIL;
if (j->using)
{
{
char *u_colname = strVal(lfirst(ucol));
List *col;
- Node *l_colvar,
- *r_colvar,
- *colvar;
+ Var *l_colvar,
+ *r_colvar;
+ Oid outcoltype;
+ int32 outcoltypmod;
int ndx;
int l_index = -1;
int r_index = -1;
res_colnames = lappend(res_colnames,
nth(l_index, l_colnames));
- switch (j->jointype)
+ /*
+ * Choose output type if input types are dissimilar.
+ */
+ outcoltype = l_colvar->vartype;
+ outcoltypmod = l_colvar->vartypmod;
+ if (outcoltype != r_colvar->vartype)
{
- case JOIN_INNER:
- case JOIN_LEFT:
- colvar = l_colvar;
- break;
- case JOIN_RIGHT:
- colvar = r_colvar;
- break;
- default:
- {
- /* Need COALESCE(l_colvar, r_colvar) */
- CaseExpr *c = makeNode(CaseExpr);
- CaseWhen *w = makeNode(CaseWhen);
- NullTest *n = makeNode(NullTest);
-
- n->arg = l_colvar;
- n->nulltesttype = IS_NOT_NULL;
- w->expr = (Node *) n;
- w->result = l_colvar;
- c->args = makeList1(w);
- c->defresult = r_colvar;
- colvar = transformExpr(pstate, (Node *) c,
- EXPR_COLUMN_FIRST);
- break;
- }
+ outcoltype =
+ select_common_type(makeListi2(l_colvar->vartype,
+ r_colvar->vartype),
+ "JOIN/USING");
+ outcoltypmod = -1; /* ie, unknown */
}
- res_colvars = lappend(res_colvars, colvar);
+ else if (outcoltypmod != r_colvar->vartypmod)
+ {
+ /* same type, but not same typmod */
+ outcoltypmod = -1; /* ie, unknown */
+ }
+ coltypes = lappendi(coltypes, outcoltype);
+ coltypmods = lappendi(coltypmods, outcoltypmod);
+ leftcolnos = lappendi(leftcolnos, l_index+1);
+ rightcolnos = lappendi(rightcolnos, r_index+1);
}
j->quals = transformJoinUsingClause(pstate,
r_colnames, r_colvars,
&r_colnames, &r_colvars);
res_colnames = nconc(res_colnames, l_colnames);
- res_colvars = nconc(res_colvars, l_colvars);
+ while (l_colvars)
+ {
+ Var *l_var = (Var *) lfirst(l_colvars);
+
+ coltypes = lappendi(coltypes, l_var->vartype);
+ coltypmods = lappendi(coltypmods, l_var->vartypmod);
+ leftcolnos = lappendi(leftcolnos, l_var->varattno);
+ rightcolnos = lappendi(rightcolnos, 0);
+ l_colvars = lnext(l_colvars);
+ }
res_colnames = nconc(res_colnames, r_colnames);
- res_colvars = nconc(res_colvars, r_colvars);
+ while (r_colvars)
+ {
+ Var *r_var = (Var *) lfirst(r_colvars);
+
+ coltypes = lappendi(coltypes, r_var->vartype);
+ coltypmods = lappendi(coltypmods, r_var->vartypmod);
+ leftcolnos = lappendi(leftcolnos, 0);
+ rightcolnos = lappendi(rightcolnos, r_var->varattno);
+ r_colvars = lnext(r_colvars);
+ }
/*
- * Process alias (AS clause), if any.
+ * Check alias (AS clause), if any.
*/
if (j->alias)
{
- /*
- * If a column alias list is specified, substitute the alias
- * names into my output-column list
- */
if (j->alias->attrs != NIL)
{
- if (length(j->alias->attrs) != length(res_colnames))
- elog(ERROR, "Column alias list for \"%s\" has wrong number of entries (need %d)",
- j->alias->relname, length(res_colnames));
- res_colnames = j->alias->attrs;
+ if (length(j->alias->attrs) > length(res_colnames))
+ elog(ERROR, "Column alias list for \"%s\" has too many entries",
+ j->alias->relname);
}
}
- j->colnames = res_colnames;
- j->colvars = res_colvars;
+ /*
+ * Now build an RTE for the result of the join
+ */
+ rte = addRangeTableEntryForJoin(pstate, res_colnames,
+ j->jointype,
+ coltypes, coltypmods,
+ leftcolnos, rightcolnos,
+ j->alias, true);
+
+ /* assume new rte is at end */
+ j->rtindex = length(pstate->p_rtable);
+ Assert(rte == rt_fetch(j->rtindex, pstate->p_rtable));
return (Node *) j;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.107 2002/03/07 16:35:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.108 2002/03/12 00:51:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* appear
*/
if (ident->indirection == NIL &&
- refnameRangeOrJoinEntry(pstate, ident->name, &sublevels_up) != NULL)
+ refnameRangeTblEntry(pstate, ident->name, &sublevels_up) != NULL)
{
ident->isRel = TRUE;
result = (Node *) ident;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.116 2002/02/19 20:11:15 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.117 2002/03/12 00:51:55 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
RangeTblEntry *rte;
int vnum;
- Node *rteorjoin;
int sublevels_up;
/*
*/
refname = ((Ident *) arg)->name;
- rteorjoin = refnameRangeOrJoinEntry(pstate, refname,
- &sublevels_up);
+ rte = refnameRangeTblEntry(pstate, refname,
+ &sublevels_up);
- if (rteorjoin == NULL)
+ if (rte == NULL)
rte = addImplicitRTE(pstate, refname);
- else if (IsA(rteorjoin, RangeTblEntry))
- rte = (RangeTblEntry *) rteorjoin;
- else if (IsA(rteorjoin, JoinExpr))
- {
- /*
- * The relation name refers to a join. We can't support
- * functions on join tuples (since we don't have a named
- * type for the join tuples), so error out.
- */
- if (nargs == 1)
- {
- /*
- * We have f(x) or more likely x.f where x is a join
- * and f is not one of the attribute names of the join
- * (else we'd have recognized it above). Give an
- * appropriately vague error message. Would be nicer
- * to know which syntax was used...
- */
- elog(ERROR, "No such attribute or function %s.%s",
- refname, funcname);
- }
- else
- {
- /*
- * There are multiple arguments, so it must be a
- * function call.
- */
- elog(ERROR, "Cannot pass result of join %s to a function",
- refname);
- }
- rte = NULL; /* keep compiler quiet */
- }
- else
- {
- elog(ERROR, "ParseFuncOrColumn: unexpected node type %d",
- nodeTag(rteorjoin));
- rte = NULL; /* keep compiler quiet */
- }
vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
* sizeof(Pointer) to signal that the runtime representation
* will be a pointer not an Oid.
*/
- if (rte->relname == NULL)
+ if (rte->rtekind != RTE_RELATION)
{
/*
- * RTE is a subselect; must fail for lack of a specific
- * type
+ * RTE is a join or subselect; must fail for lack of a
+ * named tuple type
*/
if (nargs == 1)
{
}
else
{
- elog(ERROR, "Cannot pass result of sub-select %s to a function",
+ elog(ERROR, "Cannot pass result of sub-select or join %s to a function",
refname);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.58 2002/03/06 06:09:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.59 2002/03/12 00:51:55 tgl Exp $
*
*-------------------------------------------------------------------------
*/
+#include "postgres.h"
+
#include <ctype.h>
#include <errno.h>
#include <float.h>
-#include "postgres.h"
-
#include "access/heapam.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_type.h"
#include "fmgr.h"
#include "nodes/makefuncs.h"
+#include "parser/parsetree.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_node.h"
{
int vnum,
sublevels_up;
- Oid vartypeid = 0;
- int32 type_mod = 0;
+ Oid vartypeid;
+ int32 type_mod;
vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
-
- if (rte->relid != InvalidOid)
- {
- /* Plain relation RTE --- get the attribute's type info */
- HeapTuple tp;
- Form_pg_attribute att_tup;
-
- tp = SearchSysCache(ATTNUM,
- ObjectIdGetDatum(rte->relid),
- Int16GetDatum(attrno),
- 0, 0);
- /* this shouldn't happen... */
- if (!HeapTupleIsValid(tp))
- elog(ERROR, "Relation %s does not have attribute %d",
- rte->relname, attrno);
- att_tup = (Form_pg_attribute) GETSTRUCT(tp);
- vartypeid = att_tup->atttypid;
- type_mod = att_tup->atttypmod;
- ReleaseSysCache(tp);
- }
- else
- {
- /* Subselect RTE --- get type info from subselect's tlist */
- List *tlistitem;
-
- foreach(tlistitem, rte->subquery->targetList)
- {
- TargetEntry *te = (TargetEntry *) lfirst(tlistitem);
-
- if (te->resdom->resjunk || te->resdom->resno != attrno)
- continue;
- vartypeid = te->resdom->restype;
- type_mod = te->resdom->restypmod;
- break;
- }
- /* falling off end of list shouldn't happen... */
- if (tlistitem == NIL)
- elog(ERROR, "Subquery %s does not have attribute %d",
- rte->eref->relname, attrno);
- }
-
+ get_rte_attribute_type(rte, attrno, &vartypeid, &type_mod);
return makeVar(vnum, attrno, vartypeid, type_mod, sublevels_up);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.62 2002/03/06 06:09:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.63 2002/03/12 00:51:56 tgl Exp $
*
*-------------------------------------------------------------------------
*/
char *refname);
static Node *scanRTEForColumn(ParseState *pstate, RangeTblEntry *rte,
char *colname);
-static Node *scanJoinForColumn(JoinExpr *join, char *colname,
- int sublevels_up);
static bool isForUpdate(ParseState *pstate, char *relname);
-static List *expandNamesVars(ParseState *pstate, List *names, List *vars);
static int specialAttNum(char *a);
static void warnAutoRange(ParseState *pstate, char *refname);
/*
- * refnameRangeOrJoinEntry
- * Given a refname, look to see if it matches any RTE or join table.
- * If so, return a pointer to the RangeTblEntry or JoinExpr.
+ * refnameRangeTblEntry
+ * Given a refname, look to see if it matches any RTE.
+ * If so, return a pointer to the RangeTblEntry.
* Optionally get its nesting depth (0 = current). If sublevels_up
* is NULL, only consider items at the current nesting level.
*/
-Node *
-refnameRangeOrJoinEntry(ParseState *pstate,
- char *refname,
- int *sublevels_up)
+RangeTblEntry *
+refnameRangeTblEntry(ParseState *pstate,
+ char *refname,
+ int *sublevels_up)
{
if (sublevels_up)
*sublevels_up = 0;
while (pstate != NULL)
{
- Node *rte;
+ Node *nsnode;
- rte = scanNameSpaceForRefname(pstate,
- (Node *) pstate->p_namespace,
- refname);
- if (rte)
- return rte;
+ nsnode = scanNameSpaceForRefname(pstate,
+ (Node *) pstate->p_namespace,
+ refname);
+ if (nsnode)
+ {
+ /* should get an RTE or JoinExpr */
+ if (IsA(nsnode, RangeTblEntry))
+ return (RangeTblEntry *) nsnode;
+ Assert(IsA(nsnode, JoinExpr));
+ return rt_fetch(((JoinExpr *) nsnode)->rtindex, pstate->p_rtable);
+ }
pstate = pstate->parentParseState;
if (sublevels_up)
*
* Side effect: if we find a match, mark the RTE as requiring read access.
* See comments in setTargetTable().
+ *
+ * NOTE: if the RTE is for a join, marking it as requiring read access does
+ * nothing. It might seem that we need to propagate the mark to all the
+ * contained RTEs, but that is not necessary. This is so because a join
+ * expression can only appear in a FROM clause, and any table named in
+ * FROM will be marked checkForRead from the beginning.
*/
static Node *
scanRTEForColumn(ParseState *pstate, RangeTblEntry *rte, char *colname)
return result;
/*
- * If the RTE represents a table (not a sub-select), consider system
- * column names.
+ * If the RTE represents a real table, consider system column names.
*/
- if (rte->relid != InvalidOid)
+ if (rte->rtekind == RTE_RELATION)
{
/* quick check to see if name could be a system column */
attnum = specialAttNum(colname);
return result;
}
-/*
- * scanJoinForColumn
- * Search the column names of a single join table for the given name.
- * If found, return an appropriate Var node or expression, else return NULL.
- * If the name proves ambiguous within this jointable, raise error.
- *
- * NOTE: unlike scanRTEForColumn, there's no need to worry about forcing
- * checkForRead true for the referenced tables. This is so because a join
- * expression can only appear in a FROM clause, and any table named in
- * FROM will be marked checkForRead from the beginning.
- */
-static Node *
-scanJoinForColumn(JoinExpr *join, char *colname, int sublevels_up)
-{
- Node *result = NULL;
- int attnum = 0;
- List *c;
-
- foreach(c, join->colnames)
- {
- attnum++;
- if (strcmp(strVal(lfirst(c)), colname) == 0)
- {
- if (result)
- elog(ERROR, "Column reference \"%s\" is ambiguous", colname);
- result = copyObject(nth(attnum - 1, join->colvars));
-
- /*
- * If referencing an uplevel join item, we must adjust
- * sublevels settings in the copied expression.
- */
- if (sublevels_up > 0)
- IncrementVarSublevelsUp(result, sublevels_up, 0);
- }
- }
- return result;
-}
-
/*
* colnameToVar
* Search for an unqualified column name.
}
else if (IsA(nsnode, JoinExpr))
{
- JoinExpr *j = (JoinExpr *) nsnode;
+ int varno = ((JoinExpr *) nsnode)->rtindex;
+ RangeTblEntry *rte = rt_fetch(varno, pstate->p_rtable);
- newresult = scanJoinForColumn(j, colname, levels_up);
+ /* joins are always inFromCl, so no need to check */
+
+ /* use orig_pstate here to get the right sublevels_up */
+ newresult = scanRTEForColumn(orig_pstate, rte, colname);
}
else
elog(ERROR, "colnameToVar: unexpected node type %d",
/*
* qualifiedNameToVar
* Search for a qualified column name (refname + column name).
- * If found, return the appropriate Var node (or expression).
+ * If found, return the appropriate Var node.
* If not found, return NULL. If the name proves ambiguous, raise error.
*/
Node *
qualifiedNameToVar(ParseState *pstate, char *refname, char *colname,
bool implicitRTEOK)
{
- Node *result;
- Node *rteorjoin;
+ RangeTblEntry *rte;
int sublevels_up;
- rteorjoin = refnameRangeOrJoinEntry(pstate, refname, &sublevels_up);
+ rte = refnameRangeTblEntry(pstate, refname, &sublevels_up);
- if (rteorjoin == NULL)
+ if (rte == NULL)
{
if (!implicitRTEOK)
return NULL;
- rteorjoin = (Node *) addImplicitRTE(pstate, refname);
- sublevels_up = 0;
+ rte = addImplicitRTE(pstate, refname);
}
- if (IsA(rteorjoin, RangeTblEntry))
- result = scanRTEForColumn(pstate, (RangeTblEntry *) rteorjoin,
- colname);
- else if (IsA(rteorjoin, JoinExpr))
- result = scanJoinForColumn((JoinExpr *) rteorjoin,
- colname, sublevels_up);
- else
- {
- elog(ERROR, "qualifiedNameToVar: unexpected node type %d",
- nodeTag(rteorjoin));
- result = NULL; /* keep compiler quiet */
- }
-
- return result;
+ return scanRTEForColumn(pstate, rte, colname);
}
/*
int numaliases;
int varattno;
+ rte->rtekind = RTE_RELATION;
rte->relname = relname;
rte->alias = alias;
- rte->subquery = NULL;
/*
* Get the rel's OID. This access also ensures that we have an
int varattno;
List *tlistitem;
+ rte->rtekind = RTE_SUBQUERY;
rte->relname = NULL;
rte->relid = InvalidOid;
rte->subquery = subquery;
return rte;
}
+/*
+ * Add an entry for a join to the pstate's range table (p_rtable).
+ *
+ * This is much like addRangeTableEntry() except that it makes a join RTE.
+ */
+RangeTblEntry *
+addRangeTableEntryForJoin(ParseState *pstate,
+ List *colnames,
+ JoinType jointype,
+ List *coltypes,
+ List *coltypmods,
+ List *leftcols,
+ List *rightcols,
+ Attr *alias,
+ bool inFromCl)
+{
+ RangeTblEntry *rte = makeNode(RangeTblEntry);
+ Attr *eref;
+ int numaliases;
+
+ rte->rtekind = RTE_JOIN;
+ rte->relname = NULL;
+ rte->relid = InvalidOid;
+ rte->subquery = NULL;
+ rte->jointype = jointype;
+ rte->joincoltypes = coltypes;
+ rte->joincoltypmods = coltypmods;
+ rte->joinleftcols = leftcols;
+ rte->joinrightcols = rightcols;
+ rte->alias = alias;
+
+ eref = alias ? (Attr *) copyObject(alias) : makeAttr("unnamed_join", NULL);
+ numaliases = length(eref->attrs);
+
+ /* fill in any unspecified alias columns */
+ if (numaliases < length(colnames))
+ {
+ while (numaliases-- > 0)
+ colnames = lnext(colnames);
+ eref->attrs = nconc(eref->attrs, colnames);
+ }
+
+ rte->eref = eref;
+
+ /*----------
+ * Flags:
+ * - this RTE should be expanded to include descendant tables,
+ * - this RTE is in the FROM clause,
+ * - this RTE should be checked for read/write access rights.
+ *
+ * Joins are never checked for access rights.
+ *----------
+ */
+ rte->inh = false; /* never true for joins */
+ rte->inFromCl = inFromCl;
+ rte->checkForRead = false;
+ rte->checkForWrite = false;
+
+ rte->checkAsUser = InvalidOid;
+
+ /*
+ * Add completed RTE to pstate's range table list, but not to join
+ * list nor namespace --- caller must do that if appropriate.
+ */
+ if (pstate != NULL)
+ pstate->p_rtable = lappend(pstate->p_rtable, rte);
+
+ return rte;
+}
+
/*
* Has the specified relname been selected FOR UPDATE?
*/
/* Need the RT index of the entry for creating Vars */
rtindex = RTERangeTablePosn(pstate, rte, &sublevels_up);
- if (rte->relname)
+ if (rte->rtekind == RTE_RELATION)
{
/* Ordinary relation RTE */
Relation rel;
int maxattrs;
+ int numaliases;
rel = heap_openr(rte->relname, AccessShareLock);
-
maxattrs = RelationGetNumberOfAttributes(rel);
+ numaliases = length(rte->eref->attrs);
for (varattno = 0; varattno < maxattrs; varattno++)
{
{
char *label;
- if (varattno < length(rte->eref->attrs))
+ if (varattno < numaliases)
label = strVal(nth(varattno, rte->eref->attrs));
else
label = NameStr(attr->attname);
heap_close(rel, AccessShareLock);
}
- else
+ else if (rte->rtekind == RTE_SUBQUERY)
{
/* Subquery RTE */
List *aliasp = rte->eref->attrs;
}
}
}
-}
+ else if (rte->rtekind == RTE_JOIN)
+ {
+ /* Join RTE */
+ List *aliasp = rte->eref->attrs;
+ List *coltypes = rte->joincoltypes;
+ List *coltypmods = rte->joincoltypmods;
-/*
- * expandRelAttrs -
- * makes a list of TargetEntry nodes for the attributes of the rel
- */
-List *
-expandRelAttrs(ParseState *pstate, RangeTblEntry *rte)
-{
- List *name_list,
- *var_list;
+ varattno = 0;
+ while (aliasp)
+ {
+ Assert(coltypes && coltypmods);
+ varattno++;
- expandRTE(pstate, rte, &name_list, &var_list);
+ if (colnames)
+ {
+ char *label = strVal(lfirst(aliasp));
- return expandNamesVars(pstate, name_list, var_list);
-}
+ *colnames = lappend(*colnames, makeString(pstrdup(label)));
+ }
-/*
- * expandJoinAttrs -
- * makes a list of TargetEntry nodes for the attributes of the join
- */
-List *
-expandJoinAttrs(ParseState *pstate, JoinExpr *join, int sublevels_up)
-{
- List *vars;
+ if (colvars)
+ {
+ Var *varnode;
- vars = copyObject(join->colvars);
+ varnode = makeVar(rtindex, varattno,
+ (Oid) lfirsti(coltypes),
+ (int32) lfirsti(coltypmods),
+ sublevels_up);
- /*
- * If referencing an uplevel join item, we must adjust sublevels
- * settings in the copied expression.
- */
- if (sublevels_up > 0)
- IncrementVarSublevelsUp((Node *) vars, sublevels_up, 0);
+ *colvars = lappend(*colvars, varnode);
+ }
- return expandNamesVars(pstate,
- copyObject(join->colnames),
- vars);
+ aliasp = lnext(aliasp);
+ coltypes = lnext(coltypes);
+ coltypmods = lnext(coltypmods);
+ }
+ Assert(coltypes == NIL && coltypmods == NIL);
+ }
+ else
+ elog(ERROR, "expandRTE: unsupported RTE kind %d",
+ (int) rte->rtekind);
}
/*
- * expandNamesVars -
- * Workhorse for "*" expansion: produce a list of targetentries
- * given lists of column names (as String nodes) and var references.
+ * expandRelAttrs -
+ * Workhorse for "*" expansion: produce a list of targetentries
+ * for the attributes of the rte
*/
-static List *
-expandNamesVars(ParseState *pstate, List *names, List *vars)
+List *
+expandRelAttrs(ParseState *pstate, RangeTblEntry *rte)
{
+ List *names,
+ *vars;
List *te_list = NIL;
+ expandRTE(pstate, rte, &names, &vars);
+
while (names)
{
char *label = strVal(lfirst(names));
return te_list;
}
-/* ----------
+/*
* get_rte_attribute_name
* Get an attribute name from a RangeTblEntry
*
* This is unlike get_attname() because we use aliases if available.
- * In particular, it will work on an RTE for a subselect, whereas
+ * In particular, it will work on an RTE for a subselect or join, whereas
* get_attname() only works on real relations.
*
* "*" is returned if the given attnum is InvalidAttrNumber --- this case
* occurs when a Var represents a whole tuple of a relation.
- *
- * XXX Actually, this is completely bogus, because refnames of RTEs are
- * not guaranteed unique, and may not even have scope across the whole
- * query. Cleanest fix would be to add refname/attname to Var nodes and
- * just print those, rather than indulging in this hack.
- * ----------
*/
char *
get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
return "*";
/*
- * If there is an alias, use it
+ * If there is an alias, use it. (This path should always be taken
+ * for non-relation RTEs.)
*/
if (attnum > 0 && attnum <= length(rte->eref->attrs))
return strVal(nth(attnum - 1, rte->eref->attrs));
/*
* Can get here for a system attribute (which never has an alias), or
* if alias name list is too short (which probably can't happen
- * anymore). Neither of these cases is valid for a subselect RTE.
+ * anymore). Neither of these cases is valid for a non-relation RTE.
*/
- if (rte->relid == InvalidOid)
+ if (rte->rtekind != RTE_RELATION)
elog(ERROR, "Invalid attnum %d for rangetable entry %s",
attnum, rte->eref->relname);
return attname;
}
+/*
+ * get_rte_attribute_type
+ * Get attribute type information from a RangeTblEntry
+ */
+void
+get_rte_attribute_type(RangeTblEntry *rte, AttrNumber attnum,
+ Oid *vartype, int32 *vartypmod)
+{
+ if (rte->rtekind == RTE_RELATION)
+ {
+ /* Plain relation RTE --- get the attribute's type info */
+ HeapTuple tp;
+ Form_pg_attribute att_tup;
+
+ tp = SearchSysCache(ATTNUM,
+ ObjectIdGetDatum(rte->relid),
+ Int16GetDatum(attnum),
+ 0, 0);
+ /* this shouldn't happen... */
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "Relation %s does not have attribute %d",
+ rte->relname, attnum);
+ att_tup = (Form_pg_attribute) GETSTRUCT(tp);
+ *vartype = att_tup->atttypid;
+ *vartypmod = att_tup->atttypmod;
+ ReleaseSysCache(tp);
+ }
+ else if (rte->rtekind == RTE_SUBQUERY)
+ {
+ /* Subselect RTE --- get type info from subselect's tlist */
+ List *tlistitem;
+
+ foreach(tlistitem, rte->subquery->targetList)
+ {
+ TargetEntry *te = (TargetEntry *) lfirst(tlistitem);
+
+ if (te->resdom->resjunk || te->resdom->resno != attnum)
+ continue;
+ *vartype = te->resdom->restype;
+ *vartypmod = te->resdom->restypmod;
+ return;
+ }
+ /* falling off end of list shouldn't happen... */
+ elog(ERROR, "Subquery %s does not have attribute %d",
+ rte->eref->relname, attnum);
+ }
+ else if (rte->rtekind == RTE_JOIN)
+ {
+ /* Join RTE --- get type info directly from join RTE */
+ Assert(attnum > 0 && attnum <= length(rte->joincoltypes));
+ *vartype = (Oid) nthi(attnum-1, rte->joincoltypes);
+ *vartypmod = nthi(attnum-1, rte->joincoltypmods);
+ }
+ else
+ elog(ERROR, "get_rte_attribute_type: unsupported RTE kind %d",
+ (int) rte->rtekind);
+}
+
/*
* given relation and att name, return id of variable
*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.76 2001/11/05 17:46:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.77 2002/03/12 00:51:56 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+
#include "nodes/makefuncs.h"
#include "parser/parsetree.h"
#include "parser/parse_coerce.h"
* Target item is relation.*, expand that table (eg.
* SELECT emp.*, dname FROM emp, dept)
*/
- Node *rteorjoin;
+ RangeTblEntry *rte;
int sublevels_up;
- rteorjoin = refnameRangeOrJoinEntry(pstate, att->relname,
- &sublevels_up);
-
- if (rteorjoin == NULL)
- {
- rteorjoin = (Node *) addImplicitRTE(pstate, att->relname);
- sublevels_up = 0;
- }
+ rte = refnameRangeTblEntry(pstate, att->relname,
+ &sublevels_up);
+ if (rte == NULL)
+ rte = addImplicitRTE(pstate, att->relname);
- if (IsA(rteorjoin, RangeTblEntry))
- p_target = nconc(p_target,
- expandRelAttrs(pstate,
- (RangeTblEntry *) rteorjoin));
- else if (IsA(rteorjoin, JoinExpr))
- p_target = nconc(p_target,
- expandJoinAttrs(pstate,
- (JoinExpr *) rteorjoin,
- sublevels_up));
- else
- elog(ERROR, "transformTargetList: unexpected node type %d",
- nodeTag(rteorjoin));
+ p_target = nconc(p_target,
+ expandRelAttrs(pstate, rte));
}
else
{
foreach(ns, pstate->p_namespace)
{
Node *n = (Node *) lfirst(ns);
+ RangeTblEntry *rte;
if (IsA(n, RangeTblRef))
- {
- RangeTblEntry *rte;
-
rte = rt_fetch(((RangeTblRef *) n)->rtindex,
pstate->p_rtable);
-
- /*
- * Ignore added-on relations that were not listed in the FROM
- * clause.
- */
- if (!rte->inFromCl)
- continue;
-
- target = nconc(target, expandRelAttrs(pstate, rte));
- }
else if (IsA(n, JoinExpr))
- {
- /* A newfangled join expression */
- JoinExpr *j = (JoinExpr *) n;
-
- /* Currently, a join expr could only have come from FROM. */
- target = nconc(target, expandJoinAttrs(pstate, j, 0));
- }
+ rte = rt_fetch(((JoinExpr *) n)->rtindex,
+ pstate->p_rtable);
else
+ {
elog(ERROR, "ExpandAllTables: unexpected node (internal error)"
"\n\t%s", nodeToString(n));
+ rte = NULL; /* keep compiler quiet */
+ }
+
+ /*
+ * Ignore added-on relations that were not listed in the FROM
+ * clause.
+ */
+ if (!rte->inFromCl)
+ continue;
+
+ target = nconc(target, expandRelAttrs(pstate, rte));
}
/* Check for SELECT *; */
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.98 2001/10/25 05:49:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.99 2002/03/12 00:51:58 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
rte = rt_fetch(rt_index, parsetree->rtable);
+ rte->rtekind = RTE_SUBQUERY;
rte->relname = NULL;
rte->relid = InvalidOid;
rte->subquery = rule_action;
(rti == PRS2_OLD_VARNO || rti == PRS2_NEW_VARNO))
continue;
- if (rte->subquery)
- {
- /* FOR UPDATE of subquery is propagated to subquery's rels */
- markQueryForUpdate(rte->subquery, false);
- }
- else
+ if (rte->rtekind == RTE_RELATION)
{
if (!intMember(rti, qry->rowMarks))
qry->rowMarks = lappendi(qry->rowMarks, rti);
rte->checkForWrite = true;
}
+ else if (rte->rtekind == RTE_SUBQUERY)
+ {
+ /* FOR UPDATE of subquery is propagated to subquery's rels */
+ markQueryForUpdate(rte->subquery, false);
+ }
}
}
* to do to this level of the query, but we must recurse into the
* subquery to expand any rule references in it.
*/
- if (rte->subquery)
+ if (rte->rtekind == RTE_SUBQUERY)
{
rte->subquery = fireRIRrules(rte->subquery);
continue;
}
+ /*
+ * Joins and other non-relation RTEs can be ignored completely.
+ */
+ if (rte->rtekind != RTE_RELATION)
+ continue;
+
/*
* If the table is not referenced in the query, then we ignore it.
* This prevents infinite expansion loop due to new rtable entries
result_relation = parsetree->resultRelation;
Assert(result_relation != 0);
rt_entry = rt_fetch(result_relation, parsetree->rtable);
+ Assert(rt_entry->rtekind == RTE_RELATION);
/*
* This may well be the first access to the result relation during the
RangeTblEntry *rte = rt_fetch(query->resultRelation,
query->rtable);
- if (rte->subquery)
+ if (rte->rtekind == RTE_SUBQUERY)
{
switch (query->commandType)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.61 2001/11/05 17:46:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.62 2002/03/12 00:51:58 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*
* Find all Var nodes in the given tree with varlevelsup == sublevels_up,
* and increment their varno fields (rangetable indexes) by 'offset'.
- * The varnoold fields are adjusted similarly. Also, RangeTblRef nodes
- * in join trees and setOp trees are adjusted.
+ * The varnoold fields are adjusted similarly. Also, RangeTblRef and
+ * JoinExpr nodes in join trees and setOp trees are adjusted.
*
* NOTE: although this has the form of a walker, we cheat and modify the
* nodes in-place. The given expression tree should have been copied
/* the subquery itself is visited separately */
return false;
}
+ if (IsA(node, JoinExpr))
+ {
+ JoinExpr *j = (JoinExpr *) node;
+
+ if (context->sublevels_up == 0)
+ j->rtindex += context->offset;
+ /* fall through to examine children */
+ }
if (IsA(node, Query))
{
/* Recurse into subselects */
* Find all Var nodes in the given tree belonging to a specific relation
* (identified by sublevels_up and rt_index), and change their varno fields
* to 'new_index'. The varnoold fields are changed too. Also, RangeTblRef
- * nodes in join trees and setOp trees are adjusted.
+ * and JoinExpr nodes in join trees and setOp trees are adjusted.
*
* NOTE: although this has the form of a walker, we cheat and modify the
* nodes in-place. The given expression tree should have been copied
/* the subquery itself is visited separately */
return false;
}
+ if (IsA(node, JoinExpr))
+ {
+ JoinExpr *j = (JoinExpr *) node;
+
+ if (context->sublevels_up == 0 &&
+ j->rtindex == context->rt_index)
+ j->rtindex = context->new_index;
+ /* fall through to examine children */
+ }
if (IsA(node, Query))
{
/* Recurse into subselects */
/* the subquery itself is visited separately */
return false;
}
+ if (IsA(node, JoinExpr))
+ {
+ JoinExpr *j = (JoinExpr *) node;
+
+ if (j->rtindex == context->rt_index &&
+ context->sublevels_up == 0)
+ return true;
+ /* fall through to examine children */
+ }
if (IsA(node, Query))
{
/* Recurse into subselects */
* back to source text
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.92 2002/03/06 19:58:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.93 2002/03/12 00:51:59 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
/*
* Each level of query context around a subtree needs a level of Var namespace.
- * The rangetable is the list of actual RTEs, and the namespace indicates
- * which parts of the rangetable are accessible (and under what aliases)
- * in the expression currently being looked at. A Var having varlevelsup=N
- * refers to the N'th item (counting from 0) in the current context's
- * namespaces list.
+ * A Var having varlevelsup=N refers to the N'th item (counting from 0) in
+ * the current context's namespaces list.
+ *
+ * The rangetable is the list of actual RTEs from the query tree.
+ *
+ * For deparsing plan trees, we allow two special RTE entries that are not
+ * part of the rtable list (mainly because they don't have consecutively
+ * allocated varnos).
*/
typedef struct
{
List *rtable; /* List of RangeTblEntry nodes */
- List *namespace; /* List of joinlist items (RangeTblRef and
- * JoinExpr nodes) */
+ int outer_varno; /* varno for outer_rte */
+ RangeTblEntry *outer_rte; /* special RangeTblEntry, or NULL */
+ int inner_varno; /* varno for inner_rte */
+ RangeTblEntry *inner_rte; /* special RangeTblEntry, or NULL */
} deparse_namespace;
deparse_context *context);
static void get_names_for_var(Var *var, deparse_context *context,
char **refname, char **attname);
-static bool get_alias_for_case(CaseExpr *caseexpr, deparse_context *context,
- char **refname, char **attname);
-static bool find_alias_in_namespace(Node *nsnode, Node *expr,
- List *rangetable, int levelsup,
- char **refname, char **attname);
-static bool phony_equal(Node *expr1, Node *expr2, int levelsup);
static void get_rule_expr(Node *node, deparse_context *context);
static void get_func_expr(Expr *expr, deparse_context *context);
static Node *strip_type_coercion(Node *expr, Oid resultType);
*
* Given the name and OID of a relation, build deparsing context for an
* expression referencing only that relation (as varno 1, varlevelsup 0).
- * This is presently sufficient for the external uses of deparse_expression.
+ * This is sufficient for many uses of deparse_expression.
* ----------
*/
List *
{
deparse_namespace *dpns;
RangeTblEntry *rte;
- RangeTblRef *rtr;
dpns = (deparse_namespace *) palloc(sizeof(deparse_namespace));
/* Build a minimal RTE for the rel */
rte = makeNode(RangeTblEntry);
+ rte->rtekind = RTE_RELATION;
rte->relname = relname;
rte->relid = relid;
rte->eref = makeNode(Attr);
rte->eref->relname = relname;
rte->inh = false;
rte->inFromCl = true;
+
/* Build one-element rtable */
dpns->rtable = makeList1(rte);
+ dpns->outer_varno = dpns->inner_varno = 0;
+ dpns->outer_rte = dpns->inner_rte = NULL;
- /* Build a namespace list referencing this RTE only */
- rtr = makeNode(RangeTblRef);
- rtr->rtindex = 1;
- dpns->namespace = makeList1(rtr);
+ /* Return a one-deep namespace stack */
+ return makeList1(dpns);
+}
+
+/*
+ * deparse_context_for_plan - Build deparse context for a plan node
+ *
+ * We assume we are dealing with an upper-level plan node having either
+ * one or two referenceable children (pass innercontext = NULL if only one).
+ * The passed-in Nodes should be made using deparse_context_for_subplan.
+ * The resulting context will work for deparsing quals, tlists, etc of the
+ * plan node.
+ */
+List *
+deparse_context_for_plan(int outer_varno, Node *outercontext,
+ int inner_varno, Node *innercontext)
+{
+ deparse_namespace *dpns;
+
+ dpns = (deparse_namespace *) palloc(sizeof(deparse_namespace));
+
+ dpns->rtable = NIL;
+ dpns->outer_varno = outer_varno;
+ dpns->outer_rte = (RangeTblEntry *) outercontext;
+ dpns->inner_varno = inner_varno;
+ dpns->inner_rte = (RangeTblEntry *) innercontext;
/* Return a one-deep namespace stack */
return makeList1(dpns);
}
+/*
+ * deparse_context_for_subplan - Build deparse context for a plan node
+ *
+ * Helper routine to build one of the inputs for deparse_context_for_plan.
+ * Pass the tlist of the subplan node, plus the query rangetable.
+ *
+ * The returned node is actually a RangeTblEntry, but we declare it as just
+ * Node to discourage callers from assuming anything.
+ */
+Node *
+deparse_context_for_subplan(const char *name, List *tlist,
+ List *rtable)
+{
+ RangeTblEntry *rte = makeNode(RangeTblEntry);
+ List *attrs = NIL;
+ int nattrs = 0;
+ int rtablelength = length(rtable);
+ List *tl;
+ char buf[32];
+
+ foreach(tl, tlist)
+ {
+ TargetEntry *tle = lfirst(tl);
+ Resdom *resdom = tle->resdom;
+
+ nattrs++;
+ Assert(resdom->resno == nattrs);
+ if (resdom->resname)
+ {
+ attrs = lappend(attrs, makeString(resdom->resname));
+ continue;
+ }
+ if (tle->expr && IsA(tle->expr, Var))
+ {
+ Var *var = (Var *) tle->expr;
+
+ /* varno/varattno won't be any good, but varnoold might be */
+ if (var->varnoold > 0 && var->varnoold <= rtablelength)
+ {
+ RangeTblEntry *varrte = rt_fetch(var->varnoold, rtable);
+ char *varname;
+
+ varname = get_rte_attribute_name(varrte, var->varoattno);
+ attrs = lappend(attrs, makeString(varname));
+ continue;
+ }
+ }
+ /* Fallback if can't get name */
+ snprintf(buf, sizeof(buf), "?column%d?", resdom->resno);
+ attrs = lappend(attrs, makeString(pstrdup(buf)));
+ }
+
+ rte->rtekind = RTE_SPECIAL; /* XXX */
+ rte->relname = pstrdup(name);
+ rte->relid = InvalidOid;
+ rte->eref = makeNode(Attr);
+ rte->eref->relname = rte->relname;
+ rte->eref->attrs = attrs;
+ rte->inh = false;
+ rte->inFromCl = true;
+
+ return (Node *) rte;
+}
+
/* ----------
* make_ruledef - reconstruct the CREATE RULE command
* for a given pg_rewrite tuple
context.namespaces = makeList1(&dpns);
context.varprefix = (length(query->rtable) != 1);
dpns.rtable = query->rtable;
- dpns.namespace = query->jointree ? query->jointree->fromlist : NIL;
+ dpns.outer_varno = dpns.inner_varno = 0;
+ dpns.outer_rte = dpns.inner_rte = NULL;
get_rule_expr(qual, &context);
}
context.varprefix = (parentnamespace != NIL ||
length(query->rtable) != 1);
dpns.rtable = query->rtable;
- dpns.namespace = query->jointree ? query->jointree->fromlist : NIL;
+ dpns.outer_varno = dpns.inner_varno = 0;
+ dpns.outer_rte = dpns.inner_rte = NULL;
switch (query->commandType)
{
/*
* Get the relation refname and attname for a (possibly nonlocal) Var.
*
+ * refname will be returned as NULL if the Var references an unnamed join.
+ * In this case the Var *must* be displayed without any qualification.
+ *
* attname will be returned as NULL if the Var represents a whole tuple
* of the relation.
- *
- * This is trickier than it ought to be because of the possibility of aliases
- * and limited scope of refnames. We have to try to return the correct alias
- * with respect to the current namespace given by the context.
*/
static void
get_names_for_var(Var *var, deparse_context *context,
var->varlevelsup);
dpns = (deparse_namespace *) lfirst(nslist);
- /* Scan namespace to see if we can find an alias for the var */
- if (find_alias_in_namespace((Node *) dpns->namespace, (Node *) var,
- dpns->rtable, var->varlevelsup,
- refname, attname))
- return;
+ /* Find the relevant RTE */
+ if (var->varno >= 1 && var->varno <= length(dpns->rtable))
+ rte = rt_fetch(var->varno, dpns->rtable);
+ else if (var->varno == dpns->outer_varno)
+ rte = dpns->outer_rte;
+ else if (var->varno == dpns->inner_varno)
+ rte = dpns->inner_rte;
+ else
+ rte = NULL;
+ if (rte == NULL)
+ elog(ERROR, "get_names_for_var: bogus varno %d",
+ var->varno);
+
+ /* Emit results */
+ if (rte->rtekind == RTE_JOIN && rte->alias == NULL)
+ *refname = NULL;
+ else
+ *refname = rte->eref->relname;
- /*
- * Otherwise, fall back on the rangetable entry. This should happen
- * only for uses of special RTEs like *NEW* and *OLD*, which won't get
- * placed in our namespace.
- */
- rte = rt_fetch(var->varno, dpns->rtable);
- *refname = rte->eref->relname;
if (var->varattno == InvalidAttrNumber)
*attname = NULL;
else
*attname = get_rte_attribute_name(rte, var->varattno);
}
-/*
- * Check to see if a CASE expression matches a FULL JOIN's output expression.
- * If so, return the refname and alias it should be expressed as.
- */
-static bool
-get_alias_for_case(CaseExpr *caseexpr, deparse_context *context,
- char **refname, char **attname)
-{
- List *nslist;
- int sup;
-
- /*
- * This could be done more efficiently if we first groveled through
- * the CASE to find varlevelsup values, but it's probably not worth
- * the trouble. All this code will go away someday anyway ...
- */
-
- sup = 0;
- foreach(nslist, context->namespaces)
- {
- deparse_namespace *dpns = (deparse_namespace *) lfirst(nslist);
-
- if (find_alias_in_namespace((Node *) dpns->namespace,
- (Node *) caseexpr,
- dpns->rtable, sup,
- refname, attname))
- return true;
- sup++;
- }
- return false;
-}
-
-/*
- * Recursively scan a namespace (same representation as a jointree) to see
- * if we can find an alias for the given expression. If so, return the
- * correct alias refname and attname. The expression may be either a plain
- * Var or a CASE expression (which may be a FULL JOIN reference).
- */
-static bool
-find_alias_in_namespace(Node *nsnode, Node *expr,
- List *rangetable, int levelsup,
- char **refname, char **attname)
-{
- if (nsnode == NULL)
- return false;
- if (IsA(nsnode, RangeTblRef))
- {
- if (IsA(expr, Var))
- {
- Var *var = (Var *) expr;
- int rtindex = ((RangeTblRef *) nsnode)->rtindex;
-
- if (var->varno == rtindex && var->varlevelsup == levelsup)
- {
- RangeTblEntry *rte = rt_fetch(rtindex, rangetable);
-
- *refname = rte->eref->relname;
- if (var->varattno == InvalidAttrNumber)
- *attname = NULL;
- else
- *attname = get_rte_attribute_name(rte, var->varattno);
- return true;
- }
- }
- }
- else if (IsA(nsnode, JoinExpr))
- {
- JoinExpr *j = (JoinExpr *) nsnode;
-
- if (j->alias)
- {
- List *vlist;
- List *nlist;
-
- /*
- * Does the expr match any of the output columns of the join?
- *
- * We can't just use equal() here, because the given expr may
- * have nonzero levelsup, whereas the saved expression in the
- * JoinExpr should have zero levelsup.
- */
- nlist = j->colnames;
- foreach(vlist, j->colvars)
- {
- if (phony_equal(lfirst(vlist), expr, levelsup))
- {
- *refname = j->alias->relname;
- *attname = strVal(lfirst(nlist));
- return true;
- }
- nlist = lnext(nlist);
- }
-
- /*
- * Tables within an aliased join are invisible from outside
- * the join, according to the scope rules of SQL92 (the join
- * is considered a subquery). So, stop here.
- */
- return false;
- }
- if (find_alias_in_namespace(j->larg, expr,
- rangetable, levelsup,
- refname, attname))
- return true;
- if (find_alias_in_namespace(j->rarg, expr,
- rangetable, levelsup,
- refname, attname))
- return true;
- }
- else if (IsA(nsnode, List))
- {
- List *l;
-
- foreach(l, (List *) nsnode)
- {
- if (find_alias_in_namespace(lfirst(l), expr,
- rangetable, levelsup,
- refname, attname))
- return true;
- }
- }
- else
- elog(ERROR, "find_alias_in_namespace: unexpected node type %d",
- nodeTag(nsnode));
- return false;
-}
-
-/*
- * Check for equality of two expressions, with the proviso that all Vars in
- * expr1 should have varlevelsup = 0, while all Vars in expr2 should have
- * varlevelsup = levelsup.
- *
- * In reality we only need to support equality checks on Vars and the type
- * of CASE expression that is used for FULL JOIN outputs, so not all node
- * types need be handled here.
- *
- * Otherwise, this code is a straight ripoff from equalfuncs.c.
- */
-static bool
-phony_equal(Node *expr1, Node *expr2, int levelsup)
-{
- if (expr1 == NULL || expr2 == NULL)
- return (expr1 == expr2);
- if (nodeTag(expr1) != nodeTag(expr2))
- return false;
- if (IsA(expr1, Var))
- {
- Var *a = (Var *) expr1;
- Var *b = (Var *) expr2;
-
- if (a->varno != b->varno)
- return false;
- if (a->varattno != b->varattno)
- return false;
- if (a->vartype != b->vartype)
- return false;
- if (a->vartypmod != b->vartypmod)
- return false;
- if (a->varlevelsup != 0 || b->varlevelsup != levelsup)
- return false;
- if (a->varnoold != b->varnoold)
- return false;
- if (a->varoattno != b->varoattno)
- return false;
- return true;
- }
- if (IsA(expr1, CaseExpr))
- {
- CaseExpr *a = (CaseExpr *) expr1;
- CaseExpr *b = (CaseExpr *) expr2;
-
- if (a->casetype != b->casetype)
- return false;
- if (!phony_equal(a->arg, b->arg, levelsup))
- return false;
- if (!phony_equal((Node *) a->args, (Node *) b->args, levelsup))
- return false;
- if (!phony_equal(a->defresult, b->defresult, levelsup))
- return false;
- return true;
- }
- if (IsA(expr1, CaseWhen))
- {
- CaseWhen *a = (CaseWhen *) expr1;
- CaseWhen *b = (CaseWhen *) expr2;
-
- if (!phony_equal(a->expr, b->expr, levelsup))
- return false;
- if (!phony_equal(a->result, b->result, levelsup))
- return false;
- return true;
- }
- if (IsA(expr1, Expr))
- {
- Expr *a = (Expr *) expr1;
- Expr *b = (Expr *) expr2;
-
- if (a->opType != b->opType)
- return false;
- if (!phony_equal(a->oper, b->oper, levelsup))
- return false;
- if (!phony_equal((Node *) a->args, (Node *) b->args, levelsup))
- return false;
- return true;
- }
- if (IsA(expr1, Func))
- {
- Func *a = (Func *) expr1;
- Func *b = (Func *) expr2;
-
- if (a->funcid != b->funcid)
- return false;
- if (a->functype != b->functype)
- return false;
- return true;
- }
- if (IsA(expr1, List))
- {
- List *la = (List *) expr1;
- List *lb = (List *) expr2;
- List *l;
-
- if (length(la) != length(lb))
- return false;
- foreach(l, la)
- {
- if (!phony_equal(lfirst(l), lfirst(lb), levelsup))
- return false;
- lb = lnext(lb);
- }
- return true;
- }
- /* If we get here, there was something weird in a JOIN's colvars list */
- elog(ERROR, "phony_equal: unexpected node type %d", nodeTag(expr1));
- return false;
-}
-
/* ----------
* get_rule_expr - Parse back an expression
* ----------
char *attname;
get_names_for_var(var, context, &refname, &attname);
- if (context->varprefix || attname == NULL)
+ if (refname && (context->varprefix || attname == NULL))
{
if (strcmp(refname, "*NEW*") == 0)
appendStringInfo(buf, "new");
appendStringInfoChar(buf, ')');
break;
+ case FUNC_EXPR:
+ get_func_expr((Expr *) node, context);
+ break;
+
case OR_EXPR:
appendStringInfoChar(buf, '(');
get_rule_expr((Node *) lfirst(args), context);
appendStringInfoChar(buf, ')');
break;
- case FUNC_EXPR:
- get_func_expr((Expr *) node, context);
+ case SUBPLAN_EXPR:
+ /*
+ * We cannot see an already-planned subplan in rule
+ * deparsing, only while EXPLAINing a query plan.
+ * For now, just punt.
+ */
+ appendStringInfo(buf, "(subplan)");
break;
default:
{
CaseExpr *caseexpr = (CaseExpr *) node;
List *temp;
- char *refname;
- char *attname;
-
- /* Hack for providing aliases for FULL JOIN outputs */
- if (get_alias_for_case(caseexpr, context,
- &refname, &attname))
- {
- if (context->varprefix)
- appendStringInfo(buf, "%s.",
- quote_identifier(refname));
- appendStringInfo(buf, "%s", quote_identifier(attname));
- break;
- }
appendStringInfo(buf, "CASE");
foreach(temp, caseexpr->args)
get_sublink_expr(node, context);
break;
+ case T_Param:
+ {
+ Param *param = (Param *) node;
+
+ switch (param->paramkind)
+ {
+ case PARAM_NAMED:
+ case PARAM_NEW:
+ case PARAM_OLD:
+ appendStringInfo(buf, "$%s", param->paramname);
+ break;
+ case PARAM_NUM:
+ case PARAM_EXEC:
+ appendStringInfo(buf, "$%d", param->paramid);
+ break;
+ default:
+ appendStringInfo(buf, "(param)");
+ break;
+ }
+ }
+ break;
+
default:
printf("\n%s\n", nodeToString(node));
elog(ERROR, "get_ruledef of %s: unknown node type %d in get_rule_expr()",
get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
{
StringInfo buf = context->buf;
- deparse_namespace *dpns;
- List *sv_namespace;
-
- /*
- * FROM-clause items have limited visibility of query's namespace.
- * Save and restore the outer namespace setting while we munge it.
- */
- dpns = (deparse_namespace *) lfirst(context->namespaces);
- sv_namespace = dpns->namespace;
- dpns->namespace = NIL;
if (IsA(jtnode, RangeTblRef))
{
}
else if (j->quals)
{
- dpns->namespace = makeList2(j->larg, j->rarg);
appendStringInfo(buf, " ON (");
get_rule_expr(j->quals, context);
appendStringInfoChar(buf, ')');
else
elog(ERROR, "get_from_clause_item: unexpected node type %d",
nodeTag(jtnode));
-
- dpns->namespace = sv_namespace;
}
/* ----------
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: catversion.h,v 1.105 2002/03/01 22:45:16 petere Exp $
+ * $Id: catversion.h,v 1.106 2002/03/12 00:51:59 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 200203011
+#define CATALOG_VERSION_NO 200203111
#endif
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.159 2002/03/08 04:37:18 tgl Exp $
+ * $Id: parsenodes.h,v 1.160 2002/03/12 00:52:01 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* RangeTblEntry -
* A range table is a List of RangeTblEntry nodes.
*
- * Currently we use the same node type for both plain relation references
- * and sub-selects in the FROM clause. It might be cleaner to abstract
- * the common fields into a "superclass" nodetype.
+ * A range table entry may represent a plain relation, a sub-select in
+ * FROM, or the result of a JOIN clause. (Only explicit JOIN syntax
+ * produces an RTE, not the implicit join resulting from multiple FROM
+ * items. This is because we only need the RTE to deal with SQL features
+ * like outer joins and join-output-column aliasing.) Other special
+ * RTE types also exist, as indicated by RTEKind.
*
* alias is an Attr node representing the AS alias-clause attached to the
* FROM expression, or NULL if no clause.
*
* inh is TRUE for relation references that should be expanded to include
* inheritance children, if the rel has any. This *must* be FALSE for
- * subquery RTEs.
+ * RTEs other than RTE_RELATION entries.
*
* inFromCl marks those range variables that are listed in the FROM clause.
* In SQL, the query can only refer to range variables listed in the
* (This allows rules to act as setuid gateways.)
*--------------------
*/
+typedef enum RTEKind
+{
+ RTE_RELATION, /* ordinary relation reference */
+ RTE_SUBQUERY, /* subquery in FROM */
+ RTE_JOIN, /* join */
+ RTE_SPECIAL /* special rule relation (NEW or OLD) */
+} RTEKind;
+
typedef struct RangeTblEntry
{
NodeTag type;
+ RTEKind rtekind; /* see above */
+
/*
- * Fields valid for a plain relation RTE (else NULL/zero):
+ * XXX the fields applicable to only some rte kinds should be merged
+ * into a union. I didn't do this yet because the diffs would impact
+ * a lot of code that is being actively worked on. FIXME later.
+ */
+
+ /*
+ * Fields valid for a plain relation or inh_relation RTE (else NULL/zero):
*/
char *relname; /* real name of the relation */
Oid relid; /* OID of the relation */
*/
Query *subquery; /* the sub-query */
+ /*
+ * Fields valid for a join RTE (else NULL):
+ *
+ * joincoltypes/joincoltypmods identify the column datatypes of the
+ * join result. joinleftcols and joinrightcols identify the source
+ * columns from the join's inputs: each entry is either a source column
+ * AttrNumber or zero. For normal columns exactly one is nonzero,
+ * but both are nonzero for a column "merged" by USING or NATURAL.
+ */
+ JoinType jointype; /* type of join */
+ List *joincoltypes; /* integer list of column type OIDs */
+ List *joincoltypmods; /* integer list of column typmods */
+ List *joinleftcols; /* integer list of left-side column #s */
+ List *joinrightcols; /* integer list of right-side column #s */
+
/*
* Fields valid in all RTEs:
*/
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: plannodes.h,v 1.53 2001/11/05 17:46:34 momjian Exp $
+ * $Id: plannodes.h,v 1.54 2002/03/12 00:52:01 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* jointype: rule for joining tuples from left and right subtrees
* joinqual: qual conditions that came from JOIN/ON or JOIN/USING
* (plan.qual contains conditions that came from WHERE)
+ * joinrti: rtable index of corresponding JOIN RTE, if any (0 if none)
*
* When jointype is INNER, joinqual and plan.qual are semantically
* interchangeable. For OUTER jointypes, the two are *not* interchangeable;
* (But plan.qual is still applied before actually returning a tuple.)
* For an outer join, only joinquals are allowed to be used as the merge
* or hash condition of a merge or hash join.
+ *
+ * joinrti is for the convenience of setrefs.c; it's not used in execution.
* ----------------
*/
typedef struct Join
Plan plan;
JoinType jointype;
List *joinqual; /* JOIN quals (in addition to plan.qual) */
+ Index joinrti; /* JOIN RTE, if any */
} Join;
/* ----------------
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.57 2001/11/05 17:46:34 momjian Exp $
+ * $Id: primnodes.h,v 1.58 2002/03/12 00:52:02 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* alias has a critical impact on semantics, because a join with an alias
* restricts visibility of the tables/columns inside it.
*
- * During parse analysis, colnames is filled with a list of String nodes
- * giving the column names (real or alias) of the output of the join,
- * and colvars is filled with a list of expressions that can be copied to
- * reference the output columns.
+ * During parse analysis, an RTE is created for the Join, and its index
+ * is filled into rtindex. This RTE is present mainly so that Vars can
+ * be created that refer to the outputs of the join.
*----------
*/
typedef struct JoinExpr
List *using; /* USING clause, if any (list of String) */
Node *quals; /* qualifiers on join, if any */
struct Attr *alias; /* user-written alias clause, if any */
- List *colnames; /* output column names (list of String) */
- List *colvars; /* output column nodes (list of
- * expressions) */
+ int rtindex; /* RT index assigned for join */
} JoinExpr;
/*----------
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: relation.h,v 1.62 2002/03/01 06:01:20 tgl Exp $
+ * $Id: relation.h,v 1.63 2002/03/12 00:52:02 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* RelOptInfo
* Per-relation information for planning/optimization
*
- * For planning purposes, a "base rel" is either a plain relation (a
- * table) or the output of a sub-SELECT that appears in the range table.
- * In either case it is uniquely identified by an RT index. A "joinrel"
- * is the joining of two or more base rels. A joinrel is identified by
- * the set of RT indexes for its component baserels.
- *
- * Note that there is only one joinrel for any given set of component
- * baserels, no matter what order we assemble them in; so an unordered
- * set is the right datatype to identify it with.
- *
- * Parts of this data structure are specific to various scan and join
- * mechanisms. It didn't seem worth creating new node types for them.
+ * For planning purposes, a "base rel" is either a plain relation (a table)
+ * or the output of a sub-SELECT that appears in the range table.
+ * In either case it is uniquely identified by an RT index. A "joinrel"
+ * is the joining of two or more base rels. A joinrel is identified by
+ * the set of RT indexes for its component baserels. We create RelOptInfo
+ * nodes for each baserel and joinrel, and store them in the Query's
+ * base_rel_list and join_rel_list respectively.
+ *
+ * Note that there is only one joinrel for any given set of component
+ * baserels, no matter what order we assemble them in; so an unordered
+ * set is the right datatype to identify it with.
+ *
+ * We also have "other rels", which are like base rels in that they refer to
+ * single RT indexes; but they are not part of the join tree, and are stored
+ * in other_rel_list not base_rel_list. An otherrel is created for each
+ * join RTE as an aid in processing Vars that refer to the join's outputs,
+ * but it serves no other purpose in planning. It is important not to
+ * confuse this otherrel with the joinrel that represents the matching set
+ * of base relations.
+ *
+ * A second category of otherrels are those made for child relations of an
+ * inheritance scan (SELECT FROM foo*). The parent table's RTE and
+ * corresponding baserel represent the whole result of the inheritance scan.
+ * The planner creates separate RTEs and associated RelOptInfos for each child
+ * table (including the parent table, in its capacity as a member of the
+ * inheritance set). These RelOptInfos are physically identical to baserels,
+ * but are otherrels because they are not in the main join tree. These added
+ * RTEs and otherrels are used to plan the scans of the individual tables in
+ * the inheritance set; then the parent baserel is given an Append plan
+ * comprising the best plans for the individual child tables.
+ *
+ * Parts of this data structure are specific to various scan and join
+ * mechanisms. It didn't seem worth creating new node types for them.
*
* relids - List of base-relation identifiers; it is a base relation
* if there is just one, a join relation if more than one
* pruneable - flag to let the planner know whether it can prune the
* pathlist of this RelOptInfo or not.
*
- * * If the relation is a base relation it will have these fields set:
+ * If the relation is a base relation it will have these fields set:
*
* issubquery - true if baserel is a subquery RTE rather than a table
* indexlist - list of IndexOptInfo nodes for relation's indexes
* upon creation of the RelOptInfo object; they are filled in when
* set_base_rel_pathlist processes the object.
*
- * Note: if a base relation is the root of an inheritance tree
- * (SELECT FROM foo*) it is still considered a base rel. We will
- * generate a list of candidate Paths for accessing that table itself,
- * and also generate baserel RelOptInfo nodes for each child table,
- * with their own candidate Path lists. Then, an AppendPath is built
- * from the cheapest Path for each of these tables, and set to be the
- * only available Path for the inheritance baserel.
+ * For otherrels that are inheritance children, these fields are filled
+ * in just as for a baserel. In otherrels for join RTEs, these fields
+ * are empty --- the only useful field of a join otherrel is its
+ * outerjoinset.
+ *
+ * If the relation is a join relation it will have these fields set:
*
- * * The presence of the remaining fields depends on the restrictions
- * and joins that the relation participates in:
+ * joinrti - RT index of corresponding JOIN RTE, if any; 0 if none
+ * joinrteids - List of RT indexes of JOIN RTEs included in this join
+ * (including joinrti)
+ *
+ * The presence of the remaining fields depends on the restrictions
+ * and joins that the relation participates in:
*
* baserestrictinfo - List of RestrictInfo nodes, containing info about
* each qualification clause in which this relation
* participates (only used for base rels)
* baserestrictcost - Estimated cost of evaluating the baserestrictinfo
* clauses at a single tuple (only used for base rels)
- * outerjoinset - If the rel appears within the nullable side of an outer
- * join, the list of all relids participating in the highest
- * such outer join; else NIL (only used for base rels)
+ * outerjoinset - For a base rel: if the rel appears within the nullable
+ * side of an outer join, the list of all relids
+ * participating in the highest such outer join; else NIL.
+ * For a join otherrel: the list of all baserel relids
+ * syntactically within the join. Otherwise, unused.
* joininfo - List of JoinInfo nodes, containing info about each join
* clause in which this relation participates
* innerjoin - List of Path nodes that represent indices that may be used
* until after the outer join is performed.
*----------
*/
+typedef enum RelOptKind
+{
+ RELOPT_BASEREL,
+ RELOPT_JOINREL,
+ RELOPT_OTHER_JOIN_REL,
+ RELOPT_OTHER_CHILD_REL
+} RelOptKind;
typedef struct RelOptInfo
{
NodeTag type;
+ RelOptKind reloptkind;
+
/* all relations included in this RelOptInfo */
Relids relids; /* integer list of base relids (RT
* indexes) */
double tuples;
struct Plan *subplan;
+ /* information about a join rel (not set for base rels!) */
+ Index joinrti;
+ List *joinrteids;
+
/* used by various scans and joins: */
List *baserestrictinfo; /* RestrictInfo structures (if
* base rel) */
bool unique; /* if a unique index */
} IndexOptInfo;
+
+/*
+ * A Var is considered to belong to a relation if it's either from one
+ * of the actual base rels making up the relation, or it's a join alias
+ * var that is included in the relation.
+ */
+#define VARISRELMEMBER(varno,rel) (intMember((varno), (rel)->relids) || \
+ intMember((varno), (rel)->joinrteids))
+
+
/*
* PathKeys
*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pathnode.h,v 1.41 2001/11/05 17:46:34 momjian Exp $
+ * $Id: pathnode.h,v 1.42 2002/03/12 00:52:03 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for relnode.c
*/
-extern RelOptInfo *build_base_rel(Query *root, int relid);
+extern void build_base_rel(Query *root, int relid);
extern RelOptInfo *build_other_rel(Query *root, int relid);
extern RelOptInfo *find_base_rel(Query *root, int relid);
+extern RelOptInfo *find_other_rel(Query *root, int relid);
+extern RelOptInfo *find_other_rel_for_join(Query *root, List *relids);
extern RelOptInfo *build_join_rel(Query *root,
RelOptInfo *outer_rel,
RelOptInfo *inner_rel,
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: planmain.h,v 1.54 2001/11/05 17:46:34 momjian Exp $
+ * $Id: planmain.h,v 1.55 2002/03/12 00:52:03 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for plan/initsplan.c
*/
+extern List *add_base_rels_to_query(Query *root, Node *jtnode);
extern void build_base_rel_tlists(Query *root, List *tlist);
extern Relids distribute_quals_to_rels(Query *root, Node *jtnode);
-extern List *add_missing_rels_to_query(Query *root, Node *jtnode);
extern void process_implied_equality(Query *root, Node *item1, Node *item2,
Oid sortop1, Oid sortop2);
/*
* prototypes for plan/setrefs.c
*/
-extern void set_plan_references(Plan *plan);
-extern List *join_references(List *clauses, List *outer_tlist,
- List *inner_tlist, Index acceptable_rel);
+extern void set_plan_references(Query *root, Plan *plan);
+extern List *join_references(List *clauses, Query *root,
+ List *outer_tlist, List *inner_tlist,
+ Index acceptable_rel, Index join_rti);
extern void fix_opids(Node *node);
/*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: var.h,v 1.17 2001/11/05 17:46:34 momjian Exp $
+ * $Id: var.h,v 1.18 2002/03/12 00:52:04 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef VAR_H
#define VAR_H
-#include "nodes/primnodes.h"
+#include "nodes/parsenodes.h"
+
extern List *pull_varnos(Node *node);
extern bool contain_var_reference(Node *node, int varno, int varattno,
extern bool contain_whole_tuple_var(Node *node, int varno, int levelsup);
extern bool contain_var_clause(Node *node);
extern List *pull_var_clause(Node *node, bool includeUpperVars);
+extern Node *flatten_join_alias_vars(Node *node, Query *root, int expandRTI);
+extern void build_join_alias_subvars(Query *root, Var *aliasvar,
+ Var **leftsubvar, Var **rightsubvar);
#endif /* VAR_H */
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_relation.h,v 1.28 2001/11/05 17:46:35 momjian Exp $
+ * $Id: parse_relation.h,v 1.29 2002/03/12 00:52:04 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_node.h"
-extern Node *refnameRangeOrJoinEntry(ParseState *pstate,
+extern RangeTblEntry *refnameRangeTblEntry(ParseState *pstate,
char *refname,
int *sublevels_up);
extern void checkNameSpaceConflicts(ParseState *pstate, Node *namespace1,
Query *subquery,
Attr *alias,
bool inFromCl);
+extern RangeTblEntry *addRangeTableEntryForJoin(ParseState *pstate,
+ List *colnames,
+ JoinType jointype,
+ List *coltypes,
+ List *coltypmods,
+ List *leftcols,
+ List *rightcols,
+ Attr *alias,
+ bool inFromCl);
extern void addRTEtoQuery(ParseState *pstate, RangeTblEntry *rte,
bool addToJoinList, bool addToNameSpace);
extern RangeTblEntry *addImplicitRTE(ParseState *pstate, char *relname);
extern void expandRTE(ParseState *pstate, RangeTblEntry *rte,
List **colnames, List **colvars);
extern List *expandRelAttrs(ParseState *pstate, RangeTblEntry *rte);
-extern List *expandJoinAttrs(ParseState *pstate, JoinExpr *join,
- int sublevels_up);
extern int attnameAttNum(Relation rd, char *a);
extern Name attnumAttName(Relation rd, int attid);
extern Oid attnumTypeId(Relation rd, int attid);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsetree.h,v 1.16 2001/11/05 17:46:35 momjian Exp $
+ * $Id: parsetree.h,v 1.17 2002/03/12 00:52:04 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*
* Given the range index of a relation, return the corresponding
* relation OID. Note that InvalidOid will be returned if the
- * RTE is for a sub-select rather than a relation.
+ * RTE is for a non-relation-type RTE.
*/
#define getrelid(rangeindex,rangetable) \
(rt_fetch(rangeindex, rangetable)->relid)
*/
extern char *get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum);
+/*
+ * Given an RTE and an attribute number, return the appropriate
+ * type and typemod info for that attribute of that RTE.
+ */
+extern void get_rte_attribute_type(RangeTblEntry *rte, AttrNumber attnum,
+ Oid *vartype, int32 *vartypmod);
+
#endif /* PARSETREE_H */
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: builtins.h,v 1.171 2001/11/05 17:46:36 momjian Exp $
+ * $Id: builtins.h,v 1.172 2002/03/12 00:52:06 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define BUILTINS_H
#include "fmgr.h"
-#include "nodes/primnodes.h"
+#include "nodes/parsenodes.h"
#include "storage/itemptr.h" /* for setLastTid() */
/*
extern char *deparse_expression(Node *expr, List *dpcontext,
bool forceprefix);
extern List *deparse_context_for(char *relname, Oid relid);
+extern List *deparse_context_for_plan(int outer_varno, Node *outercontext,
+ int inner_varno, Node *innercontext);
+extern Node *deparse_context_for_subplan(const char *name, List *tlist,
+ List *rtable);
/* tid.c */
extern void setLastTid(const ItemPointer tid);
SELECT '' AS "xxx", *
FROM J1_TBL UNION JOIN J2_TBL;
ERROR: UNION JOIN is not implemented yet
+--
+-- Multiway full join
+--
+CREATE TABLE t1 (name TEXT, n INTEGER);
+CREATE TABLE t2 (name TEXT, n INTEGER);
+CREATE TABLE t3 (name TEXT, n INTEGER);
+INSERT INTO t1 VALUES ( 'aa', 11 );
+INSERT INTO t2 VALUES ( 'aa', 12 );
+INSERT INTO t2 VALUES ( 'bb', 22 );
+INSERT INTO t2 VALUES ( 'dd', 42 );
+INSERT INTO t3 VALUES ( 'aa', 13 );
+INSERT INTO t3 VALUES ( 'bb', 23 );
+INSERT INTO t3 VALUES ( 'cc', 33 );
+SELECT * FROM t1 FULL JOIN t2 USING (name) FULL JOIN t3 USING (name);
+ name | n | n | n
+------+----+----+----
+ aa | 11 | 12 | 13
+ bb | | 22 | 23
+ cc | | | 33
+ dd | | 42 |
+(4 rows)
+
--
-- Clean up
--
+DROP TABLE t1;
+DROP TABLE t2;
+DROP TABLE t3;
DROP TABLE J1_TBL;
DROP TABLE J2_TBL;
SELECT '' AS "xxx", *
FROM J1_TBL UNION JOIN J2_TBL;
+--
+-- Multiway full join
+--
+
+CREATE TABLE t1 (name TEXT, n INTEGER);
+CREATE TABLE t2 (name TEXT, n INTEGER);
+CREATE TABLE t3 (name TEXT, n INTEGER);
+
+INSERT INTO t1 VALUES ( 'aa', 11 );
+INSERT INTO t2 VALUES ( 'aa', 12 );
+INSERT INTO t2 VALUES ( 'bb', 22 );
+INSERT INTO t2 VALUES ( 'dd', 42 );
+INSERT INTO t3 VALUES ( 'aa', 13 );
+INSERT INTO t3 VALUES ( 'bb', 23 );
+INSERT INTO t3 VALUES ( 'cc', 33 );
+
+SELECT * FROM t1 FULL JOIN t2 USING (name) FULL JOIN t3 USING (name);
+
--
-- Clean up
--
+DROP TABLE t1;
+DROP TABLE t2;
+DROP TABLE t3;
+
DROP TABLE J1_TBL;
DROP TABLE J2_TBL;
-
projects / postgresql / commitdiff