*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.94 2000/11/05 00:15:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.95 2000/11/09 02:46:16 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static Plan *make_groupplan(List *group_tlist, bool tuplePerGroup,
List *groupClause, AttrNumber *grpColIdx,
bool is_presorted, Plan *subplan);
+static List *postprocess_setop_tlist(List *new_tlist, List *orig_tlist);
+
/*****************************************************************************
*
if (parse->setOperations)
{
/*
- * Construct the plan for set operations. The result will
- * not need any work except perhaps a top-level sort.
+ * Construct the plan for set operations. The result will not
+ * need any work except perhaps a top-level sort and/or LIMIT.
*/
result_plan = plan_set_operations(parse);
/*
* We should not need to call preprocess_targetlist, since we must
- * be in a SELECT query node.
+ * be in a SELECT query node. Instead, use the targetlist
+ * returned by plan_set_operations (since this tells whether it
+ * returned any resjunk columns!), and transfer any sort key
+ * information from the original tlist.
*/
Assert(parse->commandType == CMD_SELECT);
+ tlist = postprocess_setop_tlist(result_plan->targetlist, tlist);
+
/*
* We leave current_pathkeys NIL indicating we do not know sort
* order. This is correct when the top set operation is UNION ALL,
return (Plan *) make_sort(sort_tlist, plannode, keyno);
}
+
+/*
+ * postprocess_setop_tlist
+ * Fix up targetlist returned by plan_set_operations().
+ *
+ * We need to transpose sort key info from the orig_tlist into new_tlist.
+ * NOTE: this would not be good enough if we supported resjunk sort keys
+ * for results of set operations --- then, we'd need to project a whole
+ * new tlist to evaluate the resjunk columns. For now, just elog if we
+ * find any resjunk columns in orig_tlist.
+ */
+static List *
+postprocess_setop_tlist(List *new_tlist, List *orig_tlist)
+{
+ List *l;
+
+ foreach(l, new_tlist)
+ {
+ TargetEntry *new_tle = (TargetEntry *) lfirst(l);
+ TargetEntry *orig_tle;
+
+ /* ignore resjunk columns in setop result */
+ if (new_tle->resdom->resjunk)
+ continue;
+
+ Assert(orig_tlist != NIL);
+ orig_tle = (TargetEntry *) lfirst(orig_tlist);
+ orig_tlist = lnext(orig_tlist);
+ if (orig_tle->resdom->resjunk)
+ elog(ERROR, "postprocess_setop_tlist: resjunk output columns not implemented");
+ Assert(new_tle->resdom->resno == orig_tle->resdom->resno);
+ Assert(new_tle->resdom->restype == orig_tle->resdom->restype);
+ new_tle->resdom->ressortgroupref = orig_tle->resdom->ressortgroupref;
+ }
+ if (orig_tlist != NIL)
+ elog(ERROR, "postprocess_setop_tlist: resjunk output columns not implemented");
+ return new_tlist;
+}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.54 2000/10/05 19:11:30 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.55 2000/11/09 02:46:17 tgl Exp $
*
*-------------------------------------------------------------------------
*/
} fix_parsetree_attnums_context;
static Plan *recurse_set_operations(Node *setOp, Query *parse,
- List *colTypes, int flag,
- List *refnames_tlist);
+ List *colTypes, bool junkOK,
+ int flag, List *refnames_tlist);
static Plan *generate_union_plan(SetOperationStmt *op, Query *parse,
List *refnames_tlist);
static Plan *generate_nonunion_plan(SetOperationStmt *op, Query *parse,
SetOperationStmt *top_union,
List *refnames_tlist);
static List *generate_setop_tlist(List *colTypes, int flag,
+ bool hack_constants,
List *input_tlist,
List *refnames_tlist);
-static bool tlist_same_datatypes(List *tlist, List *colTypes);
+static bool tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK);
static void fix_parsetree_attnums(Index rt_index, Oid old_relid,
Oid new_relid, Query *parsetree);
static bool fix_parsetree_attnums_walker(Node *node,
/*
* Recurse on setOperations tree to generate plans for set ops.
* The final output plan should have just the column types shown
- * as the output from the top-level node.
+ * as the output from the top-level node, plus possibly a resjunk
+ * working column (we can rely on upper-level nodes to deal with that).
*/
return recurse_set_operations((Node *) topop, parse,
- topop->colTypes, -1,
+ topop->colTypes, true, -1,
leftmostQuery->targetList);
}
* Recursively handle one step in a tree of set operations
*
* colTypes: integer list of type OIDs of expected output columns
+ * junkOK: if true, child resjunk columns may be left in the result
* flag: if >= 0, add a resjunk output column indicating value of flag
* refnames_tlist: targetlist to take column names from
*/
static Plan *
recurse_set_operations(Node *setOp, Query *parse,
- List *colTypes, int flag,
- List *refnames_tlist)
+ List *colTypes, bool junkOK,
+ int flag, List *refnames_tlist)
{
if (IsA(setOp, RangeTblRef))
{
* Add a SubqueryScan with the caller-requested targetlist
*/
plan = (Plan *)
- make_subqueryscan(generate_setop_tlist(colTypes, flag,
+ make_subqueryscan(generate_setop_tlist(colTypes, flag, true,
subplan->targetlist,
refnames_tlist),
NIL,
* the referencing Vars will equal the tlist entries they reference.
* Ugly but I don't feel like making that code more general right now.
*/
- if (flag >= 0 || ! tlist_same_datatypes(plan->targetlist, colTypes))
+ if (flag >= 0 ||
+ ! tlist_same_datatypes(plan->targetlist, colTypes, junkOK))
{
plan = (Plan *)
- make_result(generate_setop_tlist(colTypes, flag,
+ make_result(generate_setop_tlist(colTypes, flag, false,
plan->targetlist,
refnames_tlist),
NULL,
make_append(planlist,
0,
NIL,
- generate_setop_tlist(op->colTypes, -1,
+ generate_setop_tlist(op->colTypes, -1, false,
((Plan *) lfirst(planlist))->targetlist,
refnames_tlist));
/*
/* Recurse on children, ensuring their outputs are marked */
lplan = recurse_set_operations(op->larg, parse,
- op->colTypes, 0,
+ op->colTypes, false, 0,
refnames_tlist);
rplan = recurse_set_operations(op->rarg, parse,
- op->colTypes, 1,
+ op->colTypes, false, 1,
refnames_tlist);
/*
* Append the child results together.
make_append(makeList2(lplan, rplan),
0,
NIL,
- generate_setop_tlist(op->colTypes, 0,
+ generate_setop_tlist(op->colTypes, 0, false,
lplan->targetlist,
refnames_tlist));
/*
top_union, refnames_tlist));
}
}
- /* Not same, so plan this child separately */
+ /*
+ * Not same, so plan this child separately.
+ *
+ * Note we disallow any resjunk columns in child results. This
+ * is necessary since the Append node that implements the union
+ * won't do any projection, and upper levels will get confused if
+ * some of our output tuples have junk and some don't. This case
+ * only arises when we have an EXCEPT or INTERSECT as child, else
+ * there won't be resjunk anyway.
+ */
return makeList1(recurse_set_operations(setOp, parse,
- top_union->colTypes, -1,
- refnames_tlist));
+ top_union->colTypes, false,
+ -1, refnames_tlist));
}
/*
*/
static List *
generate_setop_tlist(List *colTypes, int flag,
+ bool hack_constants,
List *input_tlist,
List *refnames_tlist)
{
* HACK: constants in the input's targetlist are copied up as-is
* rather than being referenced as subquery outputs. This is mainly
* to ensure that when we try to coerce them to the output column's
- * datatype, the right things happen for UNKNOWN constants.
+ * datatype, the right things happen for UNKNOWN constants. But do
+ * this only at the first level of subquery-scan plans; we don't
+ * want phony constants appearing in the output tlists of upper-level
+ * nodes!
*/
resdom = makeResdom((AttrNumber) resno++,
colType,
-1,
pstrdup(reftle->resdom->resname),
false);
- if (inputtle->expr && IsA(inputtle->expr, Const))
+ if (hack_constants && inputtle->expr && IsA(inputtle->expr, Const))
expr = inputtle->expr;
else
expr = (Node *) makeVar(0,
/*
* Does tlist have same datatypes as requested colTypes?
*
- * Resjunk columns are ignored.
+ * Resjunk columns are ignored if junkOK is true; otherwise presence of
+ * a resjunk column will always cause a 'false' result.
*/
static bool
-tlist_same_datatypes(List *tlist, List *colTypes)
+tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK)
{
List *i;
{
TargetEntry *tle = (TargetEntry *) lfirst(i);
- if (!tle->resdom->resjunk)
+ if (tle->resdom->resjunk)
+ {
+ if (! junkOK)
+ return false;
+ }
+ else
{
if (colTypes == NIL)
return false;
projects / postgresql.git / commitdiff