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

 *        $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.277 2009/06/11 14:48:59 momjian Exp $

                                          HeapTuple func_tuple,

                                          eval_const_expressions_context *context);

                                                                 int nargs, List *args);

                                                  substitute_actual_srf_parameters_context *context);

                 * Complain if the window function's arguments contain window

                 * functions

                 * unlikely anyone would write "v1 IS NULL OR v1 IS NULL". Likewise,

                 * the NOT case isn't worth expending code on.

                        Var                *var = (Var *) expr->arg;

                        Var                *var = (Var *) expr->arg;

                context.glob = root->glob;              /* for inlined-function dependencies */

                 * then the result type's input function.  So, try to simplify it as

                 * though it were a stack of two such function calls.  First we need

                 * to know what the functions are.

                 * Reduce constants in the ArrayCoerceExpr's argument, then build a

                 * new ArrayCoerceExpr.

        if (IsA(node, PlaceHolderVar) &&context->estimate)

 * data types already.  We have to re-resolve polymorphics and do coercion

         * fail at runtime anyway.      Note that check_sql_fn_retval will also insert

         * Since there is now no trace of the function in the plan tree, we must

         * explicitly record the plan's dependency on the function.

         * Prepare expr for execution.  (Note: we can't use ExecPrepareExpr

         * It doesn't make a lot of sense for a SQL SRF to refer to itself in its

         * own FROM clause, since that must cause infinite recursion at runtime.

         * It will cause this code to recurse too, so check for stack overflow.

         * (There's no need to do more.)

         * change the results if the contained SELECT didn't return exactly one

         * row.

         * change in behavior.  Sub-selects are rejected partly for implementation

         * properties.  In particular it mustn't be declared STRICT, since we

         * Parse, analyze, and rewrite (unlike inline_function(), we can't skip

         * rewriting here).  We can fail as soon as we find more than one query,

         * though.

                                                                                        argtypes, funcform->pronargs);

         * fail at runtime anyway.      Note that check_sql_fn_retval will also insert

         * If the function returns a composite type, don't inline unless the check

         * shows it's returning a whole tuple result; otherwise what it's

         * returning is a single composite column which is not what we need.

         * Copy the modified query out of the temporary memory context, and clean

         * up.

         * Since there is now no trace of the function in the plan tree, we must

         * explicitly record the plan's dependency on the function.

                                                   substitute_actual_srf_parameters_context *context)

        Node       *result;

                                                                        substitute_actual_srf_parameters_mutator,

                         * Since the parameter is being inserted into a subquery, we must

                         * adjust levels.