clauses.h File Reference

#include "nodes/pathnodes.h"

Include dependency graph for clauses.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	WindowFuncLists

Functions
bool	contain_agg_clause (Node *clause)
bool	contain_window_function (Node *clause)
WindowFuncLists *	find_window_functions (Node *clause, Index maxWinRef)
double	expression_returns_set_rows (PlannerInfo *root, Node *clause)
bool	contain_subplans (Node *clause)
char	max_parallel_hazard (Query *parse)
bool	is_parallel_safe (PlannerInfo *root, Node *node)
bool	contain_nonstrict_functions (Node *clause)
bool	contain_exec_param (Node *clause, List *param_ids)
bool	contain_leaked_vars (Node *clause)
Relids	find_nonnullable_rels (Node *clause)
List *	find_nonnullable_vars (Node *clause)
List *	find_forced_null_vars (Node *node)
Var *	find_forced_null_var (Node *node)
bool	query_outputs_are_not_nullable (Query *query)
bool	is_pseudo_constant_clause (Node *clause)
bool	is_pseudo_constant_clause_relids (Node *clause, Relids relids)
int	NumRelids (PlannerInfo *root, Node *clause)
void	CommuteOpExpr (OpExpr *clause)
Query *	inline_function_in_from (PlannerInfo *root, RangeTblEntry *rte)
Bitmapset *	pull_paramids (Expr *expr)

Function Documentation

CommuteOpExpr()

void CommuteOpExpr ( OpExpr *  clause )

extern

Definition at line 2390 of file clauses.c.

{
    Oid         opoid;
    Node       *temp;
 
    /* Sanity checks: caller is at fault if these fail */
    if (!is_opclause(clause) ||
        list_length(clause->args) != 2)
        elog(ERROR, "cannot commute non-binary-operator clause");
 
    opoid = get_commutator(clause->opno);
 
    if (!OidIsValid(opoid))
        elog(ERROR, "could not find commutator for operator %u",
             clause->opno);
 
    /*
     * modify the clause in-place!
     */
    clause->opno = opoid;
    clause->opfuncid = InvalidOid;
    /* opresulttype, opretset, opcollid, inputcollid need not change */
 
    temp = linitial(clause->args);
    linitial(clause->args) = lsecond(clause->args);
    lsecond(clause->args) = temp;
}

References OpExpr::args, elog, ERROR, fb(), get_commutator(), InvalidOid, is_opclause(), linitial, list_length(), lsecond, OidIsValid, and OpExpr::opno.

Referenced by get_switched_clauses().

contain_agg_clause()

bool contain_agg_clause ( Node *  clause )

extern

Definition at line 192 of file clauses.c.

{
    return contain_agg_clause_walker(clause, NULL);
}

References contain_agg_clause_walker(), and fb().

Referenced by get_eclass_for_sort_expr(), mark_nullable_by_grouping(), and subquery_planner().

contain_exec_param()

bool contain_exec_param ( Node *  clause, List *  param_ids  )

extern

Definition at line 1150 of file clauses.c.

{
    return contain_exec_param_walker(clause, param_ids);
}

References contain_exec_param_walker(), and fb().

Referenced by test_opexpr_is_hashable().

contain_leaked_vars()

bool contain_leaked_vars ( Node *  clause )

extern

Definition at line 1276 of file clauses.c.

{
    return contain_leaked_vars_walker(clause, NULL);
}

References contain_leaked_vars_walker(), and fb().

Referenced by make_plain_restrictinfo(), and qual_is_pushdown_safe().

contain_nonstrict_functions()

bool contain_nonstrict_functions ( Node *  clause )

extern

Definition at line 1004 of file clauses.c.

{
    return contain_nonstrict_functions_walker(clause, NULL);
}

References contain_nonstrict_functions_walker(), and fb().

Referenced by inline_function(), and pullup_replace_vars_callback().

contain_subplans()

bool contain_subplans ( Node *  clause )

extern

Definition at line 341 of file clauses.c.

{
    return contain_subplans_walker(clause, NULL);
}

References contain_subplans_walker(), and fb().

Referenced by convert_EXISTS_to_ANY(), ExecInitValuesScan(), find_simplified_clause(), find_window_run_conditions(), initialize_peragg(), inline_function(), inline_function_in_from(), qual_is_pushdown_safe(), and subquery_planner().

contain_window_function()

bool contain_window_function ( Node *  clause )

extern

Definition at line 229 of file clauses.c.

{
    return contain_windowfuncs(clause);
}

References contain_windowfuncs().

Referenced by get_eclass_for_sort_expr(), and mark_nullable_by_grouping().

expression_returns_set_rows()

double expression_returns_set_rows ( PlannerInfo *  root, Node *  clause  )

extern

Definition at line 300 of file clauses.c.

{
    if (clause == NULL)
        return 1.0;
    if (IsA(clause, FuncExpr))
    {
        FuncExpr   *expr = (FuncExpr *) clause;
 
        if (expr->funcretset)
            return clamp_row_est(get_function_rows(root, expr->funcid, clause));
    }
    if (IsA(clause, OpExpr))
    {
        OpExpr     *expr = (OpExpr *) clause;
 
        if (expr->opretset)
        {
            set_opfuncid(expr);
            return clamp_row_est(get_function_rows(root, expr->opfuncid, clause));
        }
    }
    return 1.0;
}

References clamp_row_est(), fb(), FuncExpr::funcid, get_function_rows(), IsA, root, and set_opfuncid().

Referenced by create_set_projection_path(), estimate_num_groups(), and set_function_size_estimates().

find_forced_null_var()

Var * find_forced_null_var ( Node *  node )

extern

Definition at line 1995 of file clauses.c.

{
    if (node == NULL)
        return NULL;
    if (IsA(node, NullTest))
    {
        /* check for var IS NULL */
        NullTest   *expr = (NullTest *) node;
 
        if (expr->nulltesttype == IS_NULL && !expr->argisrow)
        {
            Var        *var = (Var *) expr->arg;
 
            if (var && IsA(var, Var) &&
                var->varlevelsup == 0)
                return var;
        }
    }
    else if (IsA(node, BooleanTest))
    {
        /* var IS UNKNOWN is equivalent to var IS NULL */
        BooleanTest *expr = (BooleanTest *) node;
 
        if (expr->booltesttype == IS_UNKNOWN)
        {
            Var        *var = (Var *) expr->arg;
 
            if (var && IsA(var, Var) &&
                var->varlevelsup == 0)
                return var;
        }
    }
    return NULL;
}

References NullTest::arg, BooleanTest::arg, BooleanTest::booltesttype, fb(), IS_NULL, IS_UNKNOWN, IsA, NullTest::nulltesttype, and Var::varlevelsup.

Referenced by check_redundant_nullability_qual(), and find_forced_null_vars().

find_forced_null_vars()

List * find_forced_null_vars ( Node *  node )

extern

Definition at line 1934 of file clauses.c.

{
    List       *result = NIL;
    Var        *var;
    ListCell   *l;
 
    if (node == NULL)
        return NIL;
    /* Check single-clause cases using subroutine */
    var = find_forced_null_var(node);
    if (var)
    {
        result = mbms_add_member(result,
                                 var->varno,
                                 var->varattno - FirstLowInvalidHeapAttributeNumber);
    }
    /* Otherwise, handle AND-conditions */
    else if (IsA(node, List))
    {
        /*
         * At top level, we are examining an implicit-AND list: if any of the
         * arms produces FALSE-or-NULL then the result is FALSE-or-NULL.
         */
        foreach(l, (List *) node)
        {
            result = mbms_add_members(result,
                                      find_forced_null_vars((Node *) lfirst(l)));
        }
    }
    else if (IsA(node, BoolExpr))
    {
        BoolExpr   *expr = (BoolExpr *) node;
 
        /*
         * We don't bother considering the OR case, because it's fairly
         * unlikely anyone would write "v1 IS NULL OR v1 IS NULL". Likewise,
         * the NOT case isn't worth expending code on.
         */
        if (expr->boolop == AND_EXPR)
        {
            /* At top level we can just recurse (to the List case) */
            result = find_forced_null_vars((Node *) expr->args);
        }
    }
    return result;
}

References AND_EXPR, BoolExpr::args, BoolExpr::boolop, fb(), find_forced_null_var(), find_forced_null_vars(), FirstLowInvalidHeapAttributeNumber, IsA, lfirst, mbms_add_member(), mbms_add_members(), NIL, Var::varattno, and Var::varno.

Referenced by find_forced_null_vars(), and reduce_outer_joins_pass2().

find_nonnullable_rels()

Relids find_nonnullable_rels ( Node *  clause )

extern

Definition at line 1474 of file clauses.c.

{
    return find_nonnullable_rels_walker(clause, true);
}

References find_nonnullable_rels_walker().

Referenced by make_outerjoininfo(), and reduce_outer_joins_pass2().

find_nonnullable_vars()

List * find_nonnullable_vars ( Node *  clause )

extern

Definition at line 1725 of file clauses.c.

{
    return find_nonnullable_vars_walker(clause, true);
}

References find_nonnullable_vars_walker().

Referenced by query_outputs_are_not_nullable(), and reduce_outer_joins_pass2().

find_window_functions()

WindowFuncLists * find_window_functions ( Node *  clause, Index  maxWinRef  )

extern

Definition at line 242 of file clauses.c.

{
    WindowFuncLists *lists = palloc_object(WindowFuncLists);
 
    lists->numWindowFuncs = 0;
    lists->maxWinRef = maxWinRef;
    lists->windowFuncs = (List **) palloc0((maxWinRef + 1) * sizeof(List *));
    (void) find_window_functions_walker(clause, lists);
    return lists;
}

References fb(), find_window_functions_walker(), palloc0(), and palloc_object.

Referenced by grouping_planner().

inline_function_in_from()

Query * inline_function_in_from ( PlannerInfo *  root, RangeTblEntry *  rte  )

extern

Definition at line 5780 of file clauses.c.

{
    RangeTblFunction *rtfunc;
    FuncExpr   *fexpr;
    Oid         func_oid;
    HeapTuple   func_tuple;
    Form_pg_proc funcform;
    MemoryContext oldcxt;
    MemoryContext mycxt;
    Datum       tmp;
    char       *src;
    inline_error_callback_arg callback_arg;
    ErrorContextCallback sqlerrcontext;
    Query      *querytree = NULL;
 
    Assert(rte->rtekind == RTE_FUNCTION);
 
    /*
     * Guard against infinite recursion during expansion by checking for stack
     * overflow.  (There's no need to do more.)
     */
    check_stack_depth();
 
    /* Fail if the RTE has ORDINALITY - we don't implement that here. */
    if (rte->funcordinality)
        return NULL;
 
    /* Fail if RTE isn't a single, simple FuncExpr */
    if (list_length(rte->functions) != 1)
        return NULL;
    rtfunc = (RangeTblFunction *) linitial(rte->functions);
 
    if (!IsA(rtfunc->funcexpr, FuncExpr))
        return NULL;
    fexpr = (FuncExpr *) rtfunc->funcexpr;
 
    func_oid = fexpr->funcid;
 
    /*
     * Refuse to inline if the arguments contain any volatile functions or
     * sub-selects.  Volatile functions are rejected because inlining may
     * result in the arguments being evaluated multiple times, risking a
     * change in behavior.  Sub-selects are rejected partly for implementation
     * reasons (pushing them down another level might change their behavior)
     * and partly because they're likely to be expensive and so multiple
     * evaluation would be bad.
     */
    if (contain_volatile_functions((Node *) fexpr->args) ||
        contain_subplans((Node *) fexpr->args))
        return NULL;
 
    /* Check permission to call function (fail later, if not) */
    if (object_aclcheck(ProcedureRelationId, func_oid, GetUserId(), ACL_EXECUTE) != ACLCHECK_OK)
        return NULL;
 
    /* Check whether a plugin wants to hook function entry/exit */
    if (FmgrHookIsNeeded(func_oid))
        return NULL;
 
    /*
     * OK, let's take a look at the function's pg_proc entry.
     */
    func_tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(func_oid));
    if (!HeapTupleIsValid(func_tuple))
        elog(ERROR, "cache lookup failed for function %u", func_oid);
    funcform = (Form_pg_proc) GETSTRUCT(func_tuple);
 
    /*
     * If the function SETs any configuration parameters, inlining would cause
     * us to miss making those changes.
     */
    if (!heap_attisnull(func_tuple, Anum_pg_proc_proconfig, NULL))
    {
        ReleaseSysCache(func_tuple);
        return NULL;
    }
 
    /*
     * Make a temporary memory context, so that we don't leak all the stuff
     * that parsing and rewriting might create.  If we succeed, we'll copy
     * just the finished query tree back up to the caller's context.
     */
    mycxt = AllocSetContextCreate(CurrentMemoryContext,
                                  "inline_function_in_from",
                                  ALLOCSET_DEFAULT_SIZES);
    oldcxt = MemoryContextSwitchTo(mycxt);
 
    /* Fetch the function body */
    tmp = SysCacheGetAttrNotNull(PROCOID, func_tuple, Anum_pg_proc_prosrc);
    src = TextDatumGetCString(tmp);
 
    /*
     * If the function has an attached support function that can handle
     * SupportRequestInlineInFrom, then attempt to inline with that.
     */
    if (funcform->prosupport)
    {
        SupportRequestInlineInFrom req;
 
        req.type = T_SupportRequestInlineInFrom;
        req.root = root;
        req.rtfunc = rtfunc;
        req.proc = func_tuple;
 
        querytree = (Query *)
            DatumGetPointer(OidFunctionCall1(funcform->prosupport,
                                             PointerGetDatum(&req)));
    }
 
    /*
     * Setup error traceback support for ereport().  This is so that we can
     * finger the function that bad information came from.  We don't install
     * this while running the support function, since it'd be likely to do the
     * wrong thing: any parse errors reported during that are very likely not
     * against the raw function source text.
     */
    callback_arg.proname = NameStr(funcform->proname);
    callback_arg.prosrc = src;
 
    sqlerrcontext.callback = sql_inline_error_callback;
    sqlerrcontext.arg = &callback_arg;
    sqlerrcontext.previous = error_context_stack;
    error_context_stack = &sqlerrcontext;
 
    /*
     * If SupportRequestInlineInFrom didn't work, try our built-in inlining
     * mechanism.
     */
    if (!querytree)
        querytree = inline_sql_function_in_from(root, rtfunc, fexpr,
                                                func_tuple, funcform, src);
 
    if (!querytree)
        goto fail;              /* no luck there either, fail */
 
    /*
     * The result had better be a SELECT Query.
     */
    Assert(IsA(querytree, Query));
    Assert(querytree->commandType == CMD_SELECT);
 
    /*
     * Looks good --- substitute parameters into the query.
     */
    querytree = substitute_actual_parameters_in_from(querytree,
                                                     funcform->pronargs,
                                                     fexpr->args);
 
    /*
     * Copy the modified query out of the temporary memory context, and clean
     * up.
     */
    MemoryContextSwitchTo(oldcxt);
 
    querytree = copyObject(querytree);
 
    MemoryContextDelete(mycxt);
    error_context_stack = sqlerrcontext.previous;
    ReleaseSysCache(func_tuple);
 
    /*
     * We don't have to fix collations here because the upper query is already
     * parsed, ie, the collations in the RTE are what count.
     */
 
    /*
     * Since there is now no trace of the function in the plan tree, we must
     * explicitly record the plan's dependency on the function.
     */
    record_plan_function_dependency(root, func_oid);
 
    /*
     * We must also notice if the inserted query adds a dependency on the
     * calling role due to RLS quals.
     */
    if (querytree->hasRowSecurity)
        root->glob->dependsOnRole = true;
 
    return querytree;
 
    /* Here if func is not inlinable: release temp memory and return NULL */
fail:
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(mycxt);
    error_context_stack = sqlerrcontext.previous;
    ReleaseSysCache(func_tuple);
 
    return NULL;
}

References ACL_EXECUTE, ACLCHECK_OK, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, check_stack_depth(), CMD_SELECT, contain_subplans(), contain_volatile_functions(), copyObject, CurrentMemoryContext, DatumGetPointer(), elog, ERROR, error_context_stack, fb(), FmgrHookIsNeeded, Form_pg_proc, RangeTblFunction::funcexpr, GETSTRUCT(), GetUserId(), heap_attisnull(), HeapTupleIsValid, inline_sql_function_in_from(), IsA, linitial, list_length(), MemoryContextDelete(), MemoryContextSwitchTo(), NameStr, object_aclcheck(), ObjectIdGetDatum(), OidFunctionCall1, PointerGetDatum(), ErrorContextCallback::previous, inline_error_callback_arg::proname, inline_error_callback_arg::prosrc, querytree(), record_plan_function_dependency(), ReleaseSysCache(), root, RTE_FUNCTION, SearchSysCache1(), sql_inline_error_callback(), substitute_actual_parameters_in_from(), SysCacheGetAttrNotNull(), TextDatumGetCString, and SupportRequestInlineInFrom::type.

Referenced by preprocess_function_rtes().

is_parallel_safe()

bool is_parallel_safe ( PlannerInfo *  root, Node *  node  )

extern

Definition at line 764 of file clauses.c.

{
    max_parallel_hazard_context context;
    PlannerInfo *proot;
    ListCell   *l;
 
    /*
     * Even if the original querytree contained nothing unsafe, we need to
     * search the expression if we have generated any PARAM_EXEC Params while
     * planning, because those are parallel-restricted and there might be one
     * in this expression.  But otherwise we don't need to look.
     */
    if (root->glob->maxParallelHazard == PROPARALLEL_SAFE &&
        root->glob->paramExecTypes == NIL)
        return true;
    /* Else use max_parallel_hazard's search logic, but stop on RESTRICTED */
    context.max_hazard = PROPARALLEL_SAFE;
    context.max_interesting = PROPARALLEL_RESTRICTED;
    context.safe_param_ids = NIL;
 
    /*
     * The params that refer to the same or parent query level are considered
     * parallel-safe.  The idea is that we compute such params at Gather or
     * Gather Merge node and pass their value to workers.
     */
    for (proot = root; proot != NULL; proot = proot->parent_root)
    {
        foreach(l, proot->init_plans)
        {
            SubPlan    *initsubplan = (SubPlan *) lfirst(l);
 
            context.safe_param_ids = list_concat(context.safe_param_ids,
                                                 initsubplan->setParam);
        }
    }
 
    return !max_parallel_hazard_walker(node, &context);
}

References fb(), lfirst, list_concat(), max_parallel_hazard_context::max_hazard, max_parallel_hazard_context::max_interesting, max_parallel_hazard_walker(), NIL, root, and max_parallel_hazard_context::safe_param_ids.

Referenced by apply_projection_to_path(), build_join_rel(), create_minmaxagg_path(), create_nestloop_plan(), create_partial_unique_paths(), create_projection_path(), create_set_projection_path(), create_window_paths(), find_computable_ec_member(), grouping_planner(), make_grouping_rel(), plan_create_index_workers(), query_planner(), relation_can_be_sorted_early(), and set_rel_consider_parallel().

is_pseudo_constant_clause()

bool is_pseudo_constant_clause ( Node *  clause )

extern

Definition at line 2331 of file clauses.c.

{
    /*
     * We could implement this check in one recursive scan.  But since the
     * check for volatile functions is both moderately expensive and unlikely
     * to fail, it seems better to look for Vars first and only check for
     * volatile functions if we find no Vars.
     */
    if (!contain_var_clause(clause) &&
        !contain_volatile_functions(clause))
        return true;
    return false;
}

References contain_var_clause(), and contain_volatile_functions().

Referenced by clauselist_selectivity_ext(), dependency_is_compatible_clause(), dependency_is_compatible_expression(), and find_window_run_conditions().

is_pseudo_constant_clause_relids()

bool is_pseudo_constant_clause_relids ( Node *  clause, Relids  relids  )

extern

Definition at line 2351 of file clauses.c.

{
    if (bms_is_empty(relids) &&
        !contain_volatile_functions(clause))
        return true;
    return false;
}

References bms_is_empty, and contain_volatile_functions().

Referenced by clauselist_selectivity_ext().

max_parallel_hazard()

char max_parallel_hazard ( Query *  parse )

extern

Definition at line 745 of file clauses.c.

{
    max_parallel_hazard_context context;
 
    context.max_hazard = PROPARALLEL_SAFE;
    context.max_interesting = PROPARALLEL_UNSAFE;
    context.safe_param_ids = NIL;
    (void) max_parallel_hazard_walker((Node *) parse, &context);
    return context.max_hazard;
}

References fb(), max_parallel_hazard_context::max_hazard, max_parallel_hazard_context::max_interesting, max_parallel_hazard_walker(), NIL, parse(), and max_parallel_hazard_context::safe_param_ids.

Referenced by standard_planner().

NumRelids()

int NumRelids ( PlannerInfo *  root, Node *  clause  )

extern

Definition at line 2373 of file clauses.c.

{
    int         result;
    Relids      varnos = pull_varnos(root, clause);
 
    varnos = bms_del_members(varnos, root->outer_join_rels);
    result = bms_num_members(varnos);
    bms_free(varnos);
    return result;
}

References bms_del_members(), bms_free(), bms_num_members(), pull_varnos(), and root.

Referenced by clauselist_selectivity_ext(), rowcomparesel(), and treat_as_join_clause().

pull_paramids()

Bitmapset * pull_paramids ( Expr *  expr )

extern

Definition at line 6204 of file clauses.c.

{
    Bitmapset  *result = NULL;
 
    (void) pull_paramids_walker((Node *) expr, &result);
 
    return result;
}

References fb(), and pull_paramids_walker().

Referenced by create_memoize_plan().

query_outputs_are_not_nullable()

bool query_outputs_are_not_nullable ( Query *  query )

extern

Definition at line 2049 of file clauses.c.

{
    PlannerInfo subroot;
    List       *safe_quals = NIL;
    List       *nonnullable_vars = NIL;
    bool        computed_nonnullable_vars = false;
 
    /*
     * If the query contains set operations, punt.  The set ops themselves
     * couldn't introduce nulls that weren't in their inputs, but the tlist
     * present in the top-level query is just dummy and won't give us useful
     * info.  We could get an answer by recursing to examine each leaf query,
     * but for the moment it doesn't seem worth the extra complication.
     */
    if (query->setOperations)
        return false;
 
    /*
     * If the query contains grouping sets, punt.  Grouping sets can introduce
     * NULL values, and we currently lack the PlannerInfo needed to flatten
     * grouping Vars in the query's outputs.
     */
    if (query->groupingSets)
        return false;
 
    /*
     * We need a PlannerInfo to pass to expr_is_nonnullable.  Fortunately, we
     * can cons up an entirely dummy one, because only the "parse" link in the
     * struct is used by expr_is_nonnullable.
     */
    MemSet(&subroot, 0, sizeof(subroot));
    subroot.parse = query;
 
    /*
     * Examine each targetlist entry to prove that it can't produce NULL.
     */
    foreach_node(TargetEntry, tle, query->targetList)
    {
        Expr       *expr = tle->expr;
 
        /* Resjunk columns can be ignored: they don't produce output values */
        if (tle->resjunk)
            continue;
 
        /*
         * Look through binary relabelings, since we know those don't
         * introduce nulls.
         */
        while (expr && IsA(expr, RelabelType))
            expr = ((RelabelType *) expr)->arg;
 
        if (expr == NULL)       /* paranoia */
            return false;
 
        /*
         * Since the subquery hasn't yet been through expression
         * preprocessing, we must explicitly flatten grouping Vars and join
         * alias Vars in the given expression.  Note that flatten_group_exprs
         * must be applied before flatten_join_alias_vars, as grouping Vars
         * can wrap join alias Vars.
         *
         * We must also apply flatten_join_alias_vars to the quals extracted
         * by find_subquery_safe_quals.  We do not need to apply
         * flatten_group_exprs to these quals, though, because grouping Vars
         * cannot appear in jointree quals.
         */
 
        /*
         * We have verified that the query does not contain grouping sets,
         * meaning the grouping Vars will not have varnullingrels that need
         * preserving, so it's safe to use NULL as the root here.
         */
        if (query->hasGroupRTE)
            expr = (Expr *) flatten_group_exprs(NULL, query, (Node *) expr);
 
        /*
         * We won't be dealing with arbitrary expressions, so it's safe to use
         * NULL as the root, so long as adjust_standard_join_alias_expression
         * can handle everything the parser would make as a join alias
         * expression.
         */
        expr = (Expr *) flatten_join_alias_vars(NULL, query, (Node *) expr);
 
        /*
         * Check to see if the expr cannot be NULL.  Since we're on a raw
         * parse tree, we need to look up the not-null constraints from the
         * system catalogs.
         */
        if (expr_is_nonnullable(&subroot, expr, NOTNULL_SOURCE_SYSCACHE))
            continue;
 
        if (IsA(expr, Var))
        {
            Var        *var = (Var *) expr;
 
            /*
             * For a plain Var, even if that didn't work, we can conclude that
             * the Var is not nullable if find_nonnullable_vars can find a
             * "var IS NOT NULL" or similarly strict condition among the quals
             * on non-outerjoined-rels.  Compute the list of Vars having such
             * quals if we didn't already.
             */
            if (!computed_nonnullable_vars)
            {
                find_subquery_safe_quals((Node *) query->jointree, &safe_quals);
                safe_quals = (List *)
                    flatten_join_alias_vars(NULL, query, (Node *) safe_quals);
                nonnullable_vars = find_nonnullable_vars((Node *) safe_quals);
                computed_nonnullable_vars = true;
            }
 
            if (!mbms_is_member(var->varno,
                                var->varattno - FirstLowInvalidHeapAttributeNumber,
                                nonnullable_vars))
                return false;   /* we failed to prove the Var non-null */
        }
        else
        {
            /* Punt otherwise */
            return false;
        }
    }
 
    return true;
}

References expr_is_nonnullable(), fb(), find_nonnullable_vars(), find_subquery_safe_quals(), FirstLowInvalidHeapAttributeNumber, flatten_group_exprs(), flatten_join_alias_vars(), foreach_node, Query::groupingSets, IsA, Query::jointree, mbms_is_member(), MemSet, NIL, NOTNULL_SOURCE_SYSCACHE, PlannerInfo::parse, Query::setOperations, Query::targetList, Var::varattno, and Var::varno.

Referenced by convert_ANY_sublink_to_join().