~ubuntu-branches/ubuntu/karmic/postgresql-8.4/karmic-security

                                                JoinExpr *lowest_outer_join,

                                                AppendRelInfo *containing_appendrel);

static void resolvenew_in_jointree(Node *jtnode, int varno, RangeTblEntry *rte,

                                           List *subtlist, List *subtlist_with_phvs,

                                           JoinExpr *lowest_outer_join);

 * If this jointree node is within the nullable side of an outer join, then

 * lowest_outer_join references the lowest such JoinExpr node; otherwise it

 * is NULL.  This forces use of the PlaceHolderVar mechanism for references

 * to non-nullable targetlist items, but only for references above that join.

 * If we are looking at a member subquery of an append relation,

 * containing_appendrel describes that relation; else it is NULL.

 * This forces use of the PlaceHolderVar mechanism for all non-Var targetlist

 * items, and puts some additional restrictions on what can be pulled up.

 * This behavior is what makes it reasonable to pass lowest_outer_join as a

 * pointer rather than some more-indirect way of identifying the lowest OJ.

 * Likewise, we don't replace append_rel_list members but only their

 * substructure, so the containing_appendrel reference is safe to use.

                                   JoinExpr *lowest_outer_join,

                                   AppendRelInfo *containing_appendrel)

                        (containing_appendrel == NULL ||

                         is_safe_append_member(rte->subquery)))

                                                                                   lowest_outer_join,

                                                                                   containing_appendrel);

                Assert(containing_appendrel == NULL);

                                                                                   lowest_outer_join, NULL);

                Assert(containing_appendrel == NULL);

                                                                                         lowest_outer_join, NULL);

                                                                                         lowest_outer_join, NULL);

                                                                                         lowest_outer_join, NULL);

                                                                                         j, NULL);

                                                                                         j, NULL);

                                                                                         j, NULL);

                                                                                         j, NULL);

                                                                                         lowest_outer_join, NULL);

 *

 * rte is the RangeTblEntry referenced by jtnode.  Remaining parameters are

 * as for pull_up_subqueries.

                                                JoinExpr *lowest_outer_join,

                                                AppendRelInfo *containing_appendrel)

        List       *subtlist_with_phvs;

        ListCell   *lc;

         * Note: we should pass NULL for containing-join info even if we are within

         * an outer join in the upper query; the lower query starts with a clean

         * slate for outer-join semantics.  Likewise, we say we aren't handling an

                pull_up_subqueries(subroot, (Node *) subquery->jointree, NULL, NULL);

                (containing_appendrel == NULL || is_safe_append_member(subquery)))

         * non-nullable items may have to be turned into PlaceHolderVars.  If we

        subtlist = subquery->targetList;

        if (lowest_outer_join != NULL || containing_appendrel != NULL)

                subtlist_with_phvs = insert_targetlist_placeholders(root,

                                                                                                                        subtlist,

                                                                                                                        varno,

                                                                                                                        containing_appendrel != NULL);

                subtlist_with_phvs = subtlist;

         * could use query_tree_mutator.)  We have to use PHVs in the targetList,

         * returningList, and havingQual, since those are certainly above any

         * outer join.  resolvenew_in_jointree tracks its location in the jointree

         * and uses PHVs or not appropriately.

                                   subtlist_with_phvs, CMD_SELECT, 0);

                                   subtlist_with_phvs, CMD_SELECT, 0);

        resolvenew_in_jointree((Node *) parse->jointree, varno, rte,

                                                   subtlist, subtlist_with_phvs,

                                                   lowest_outer_join);

                                   subtlist_with_phvs, CMD_SELECT, 0);

 

        /*

         * Replace references in the translated_vars lists of appendrels.

         * When pulling up an appendrel member, we do not need PHVs in the list

         * of the parent appendrel --- there isn't any outer join between.

         * Elsewhere, use PHVs for safety.  (This analysis could be made tighter

         * but it seems unlikely to be worth much trouble.)

         */

        foreach(lc, root->append_rel_list)

        {

                AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(lc);

 

                appinfo->translated_vars = (List *)

                        ResolveNew((Node *) appinfo->translated_vars,

                                           varno, 0, rte,

                                           (appinfo == containing_appendrel) ?

                                           subtlist : subtlist_with_phvs,

                                           CMD_SELECT, 0);

        }

 

        /*

         * Replace references in the joinaliasvars lists of join RTEs.

         *

         * You might think that we could avoid using PHVs for alias vars of joins

         * below lowest_outer_join, but that doesn't work because the alias vars

         * could be referenced above that join; we need the PHVs to be present

         * in such references after the alias vars get flattened.  (It might be

         * worth trying to be smarter here, someday.)

         */

        foreach(lc, parse->rtable)

        {

                RangeTblEntry *otherrte = (RangeTblEntry *) lfirst(lc);

                                                   subtlist_with_phvs, CMD_SELECT, 0);

                 * Note that we can pass NULL for containing-join info even if we're

                (void) pull_up_subqueries(root, (Node *) rtr, NULL, appinfo);

 *        join).

        List       *result = NIL;

                TargetEntry *newtle;

                /* resjunk columns need not be changed */

                {

                        result = lappend(result, tle);

                }

                {

                        result = lappend(result, tle);

                }

                        {

                                result = lappend(result, tle);

                        }

                newtle = makeNode(TargetEntry);

                memcpy(newtle, tle, sizeof(TargetEntry));

                newtle->expr = (Expr *)

                        make_placeholder_expr(root,

                                                                  tle->expr,

                                                                  bms_make_singleton(varno));

                result = lappend(result, newtle);

        return result;

 *

 * If we are above lowest_outer_join then use subtlist_with_phvs; at or

 * below it, use subtlist.  (When no outer joins are in the picture,

 * these will be the same list.)

resolvenew_in_jointree(Node *jtnode, int varno, RangeTblEntry *rte,

                                           List *subtlist, List *subtlist_with_phvs,

                                           JoinExpr *lowest_outer_join)

                        resolvenew_in_jointree(lfirst(l), varno, rte,

                                                                   subtlist, subtlist_with_phvs,

                                                                   lowest_outer_join);

                                                          subtlist_with_phvs, CMD_SELECT, 0);

                if (j == lowest_outer_join)

                {

                        /* no more PHVs in or below this join */

                        subtlist_with_phvs = subtlist;

                        lowest_outer_join = NULL;

                }

                resolvenew_in_jointree(j->larg, varno, rte,

                                                           subtlist, subtlist_with_phvs,

                                                           lowest_outer_join);

                resolvenew_in_jointree(j->rarg, varno, rte,

                                                           subtlist, subtlist_with_phvs,

                                                           lowest_outer_join);

                                                          subtlist_with_phvs, CMD_SELECT, 0);