analyze.h File Reference

#include "nodes/params.h"
#include "nodes/queryjumble.h"
#include "parser/parse_node.h"

Include dependency graph for analyze.h:

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

Go to the source code of this file.

Typedefs
typedef void(*	post_parse_analyze_hook_type) (ParseState *pstate, Query *query, const JumbleState *jstate)

Functions
Query *	parse_analyze_fixedparams (RawStmt *parseTree, const char *sourceText, const Oid *paramTypes, int numParams, QueryEnvironment *queryEnv)
Query *	parse_analyze_varparams (RawStmt *parseTree, const char *sourceText, Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv)
Query *	parse_analyze_withcb (RawStmt *parseTree, const char *sourceText, ParserSetupHook parserSetup, void *parserSetupArg, QueryEnvironment *queryEnv)
Query *	parse_sub_analyze (Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
List *	transformInsertRow (ParseState *pstate, List *exprlist, List *stmtcols, List *icolumns, List *attrnos, bool strip_indirection)
List *	transformUpdateTargetList (ParseState *pstate, List *origTlist, ForPortionOfExpr *forPortionOf)
void	transformReturningClause (ParseState *pstate, Query *qry, ReturningClause *returningClause, ParseExprKind exprKind)
Query *	transformTopLevelStmt (ParseState *pstate, RawStmt *parseTree)
Query *	transformStmt (ParseState *pstate, Node *parseTree)
bool	stmt_requires_parse_analysis (RawStmt *parseTree)
bool	analyze_requires_snapshot (RawStmt *parseTree)
bool	query_requires_rewrite_plan (Query *query)
const char *	LCS_asString (LockClauseStrength strength)
void	CheckSelectLocking (Query *qry, LockClauseStrength strength)
void	applyLockingClause (Query *qry, Index rtindex, LockClauseStrength strength, LockWaitPolicy waitPolicy, bool pushedDown)
List *	BuildOnConflictExcludedTargetlist (Relation targetrel, Index exclRelIndex)
SortGroupClause *	makeSortGroupClauseForSetOp (Oid rescoltype, bool require_hash)
void	constructSetOpTargetlist (ParseState *pstate, SetOperationStmt *op, const List *ltargetlist, const List *rtargetlist, List **targetlist, const char *context, bool recursive)

Variables
PGDLLIMPORT post_parse_analyze_hook_type	post_parse_analyze_hook

Typedef Documentation

post_parse_analyze_hook_type

typedef void(* post_parse_analyze_hook_type) (ParseState *pstate, Query *query, const JumbleState *jstate)

Definition at line 22 of file analyze.h.

Function Documentation

analyze_requires_snapshot()

bool analyze_requires_snapshot ( RawStmt *  parseTree )

extern

Definition at line 513 of file analyze.c.

{
    /*
     * Currently, this should return true in exactly the same cases that
     * stmt_requires_parse_analysis() does, so we just invoke that function
     * rather than duplicating it.  We keep the two entry points separate for
     * clarity of callers, since from the callers' standpoint these are
     * different conditions.
     *
     * While there may someday be a statement type for which transformStmt()
     * does something nontrivial and yet no snapshot is needed for that
     * processing, it seems likely that making such a choice would be fragile.
     * If you want to install an exception, document the reasoning for it in a
     * comment.
     */
    return stmt_requires_parse_analysis(parseTree);
}

References fb(), and stmt_requires_parse_analysis().

Referenced by BuildingPlanRequiresSnapshot(), exec_bind_message(), exec_parse_message(), and exec_simple_query().

applyLockingClause()

void applyLockingClause ( Query *  qry, Index  rtindex, LockClauseStrength  strength, LockWaitPolicy  waitPolicy, bool  pushedDown  )

extern

Definition at line 4036 of file analyze.c.

{
    RowMarkClause *rc;
 
    Assert(strength != LCS_NONE);   /* else caller error */
 
    /* If it's an explicit clause, make sure hasForUpdate gets set */
    if (!pushedDown)
        qry->hasForUpdate = true;
 
    /* Check for pre-existing entry for same rtindex */
    if ((rc = get_parse_rowmark(qry, rtindex)) != NULL)
    {
        /*
         * If the same RTE is specified with more than one locking strength,
         * use the strongest.  (Reasonable, since you can't take both a shared
         * and exclusive lock at the same time; it'll end up being exclusive
         * anyway.)
         *
         * Similarly, if the same RTE is specified with more than one lock
         * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
         * turn wins over waiting for the lock (the default).  This is a bit
         * more debatable but raising an error doesn't seem helpful. (Consider
         * for instance SELECT FOR UPDATE NOWAIT from a view that internally
         * contains a plain FOR UPDATE spec.)  Having NOWAIT win over SKIP
         * LOCKED is reasonable since the former throws an error in case of
         * coming across a locked tuple, which may be undesirable in some
         * cases but it seems better than silently returning inconsistent
         * results.
         *
         * And of course pushedDown becomes false if any clause is explicit.
         */
        rc->strength = Max(rc->strength, strength);
        rc->waitPolicy = Max(rc->waitPolicy, waitPolicy);
        rc->pushedDown &= pushedDown;
        return;
    }
 
    /* Make a new RowMarkClause */
    rc = makeNode(RowMarkClause);
    rc->rti = rtindex;
    rc->strength = strength;
    rc->waitPolicy = waitPolicy;
    rc->pushedDown = pushedDown;
    qry->rowMarks = lappend(qry->rowMarks, rc);
}

References Assert, fb(), get_parse_rowmark(), lappend(), LCS_NONE, makeNode, Max, RowMarkClause::pushedDown, Query::rowMarks, RowMarkClause::rti, RowMarkClause::strength, and RowMarkClause::waitPolicy.

Referenced by markQueryForLocking(), and transformLockingClause().

BuildOnConflictExcludedTargetlist()

List * BuildOnConflictExcludedTargetlist ( Relation  targetrel, Index  exclRelIndex  )

extern

Definition at line 1628 of file analyze.c.

{
    List       *result = NIL;
    int         attno;
    Var        *var;
    TargetEntry *te;
 
    /*
     * Note that resnos of the tlist must correspond to attnos of the
     * underlying relation, hence we need entries for dropped columns too.
     */
    for (attno = 0; attno < RelationGetNumberOfAttributes(targetrel); attno++)
    {
        Form_pg_attribute attr = TupleDescAttr(targetrel->rd_att, attno);
        char       *name;
 
        if (attr->attisdropped)
        {
            /*
             * can't use atttypid here, but it doesn't really matter what type
             * the Const claims to be.
             */
            var = (Var *) makeNullConst(INT4OID, -1, InvalidOid);
            name = NULL;
        }
        else
        {
            var = makeVar(exclRelIndex, attno + 1,
                          attr->atttypid, attr->atttypmod,
                          attr->attcollation,
                          0);
            name = pstrdup(NameStr(attr->attname));
        }
 
        te = makeTargetEntry((Expr *) var,
                             attno + 1,
                             name,
                             false);
 
        result = lappend(result, te);
    }
 
    /*
     * Add a whole-row-Var entry to support references to "EXCLUDED.*".  Like
     * the other entries in the EXCLUDED tlist, its resno must match the Var's
     * varattno, else the wrong things happen while resolving references in
     * setrefs.c.  This is against normal conventions for targetlists, but
     * it's okay since we don't use this as a real tlist.
     */
    var = makeVar(exclRelIndex, InvalidAttrNumber,
                  targetrel->rd_rel->reltype,
                  -1, InvalidOid, 0);
    te = makeTargetEntry((Expr *) var, InvalidAttrNumber, NULL, true);
    result = lappend(result, te);
 
    return result;
}

References fb(), InvalidAttrNumber, InvalidOid, lappend(), makeNullConst(), makeTargetEntry(), makeVar(), name, NameStr, NIL, pstrdup(), RelationGetNumberOfAttributes, result, and TupleDescAttr().

Referenced by rewriteTargetView(), and transformOnConflictClause().

CheckSelectLocking()

void CheckSelectLocking ( Query *  qry, LockClauseStrength  strength  )

extern

Definition at line 3745 of file analyze.c.

{
    Assert(strength != LCS_NONE);   /* else caller error */
 
    if (qry->setOperations)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
                        LCS_asString(strength))));
    if (qry->distinctClause != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with DISTINCT clause",
                        LCS_asString(strength))));
    if (qry->groupClause != NIL || qry->groupingSets != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with GROUP BY clause",
                        LCS_asString(strength))));
    if (qry->havingQual != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with HAVING clause",
                        LCS_asString(strength))));
    if (qry->hasAggs)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with aggregate functions",
                        LCS_asString(strength))));
    if (qry->hasWindowFuncs)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with window functions",
                        LCS_asString(strength))));
    if (qry->hasTargetSRFs)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with set-returning functions in the target list",
                        LCS_asString(strength))));
}

References Assert, Query::distinctClause, ereport, errcode(), errmsg, ERROR, fb(), Query::groupClause, Query::groupingSets, Query::havingQual, LCS_asString(), LCS_NONE, NIL, and Query::setOperations.

Referenced by preprocess_rowmarks(), and transformLockingClause().

constructSetOpTargetlist()

void constructSetOpTargetlist ( ParseState *  pstate, SetOperationStmt *  op, const List *  ltargetlist, const List *  rtargetlist, List **  targetlist, const char *  context, bool  recursive  )

extern

Definition at line 2609 of file analyze.c.

{
    ListCell   *ltl;
    ListCell   *rtl;
 
    /*
     * Verify that the two children have the same number of non-junk columns,
     * and determine the types of the merged output columns.
     */
    if (list_length(ltargetlist) != list_length(rtargetlist))
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("each %s query must have the same number of columns",
                        context),
                 parser_errposition(pstate,
                                    exprLocation((const Node *) rtargetlist))));
 
    if (targetlist)
        *targetlist = NIL;
    op->colTypes = NIL;
    op->colTypmods = NIL;
    op->colCollations = NIL;
    op->groupClauses = NIL;
 
    forboth(ltl, ltargetlist, rtl, rtargetlist)
    {
        TargetEntry *ltle = (TargetEntry *) lfirst(ltl);
        TargetEntry *rtle = (TargetEntry *) lfirst(rtl);
        Node       *lcolnode = (Node *) ltle->expr;
        Node       *rcolnode = (Node *) rtle->expr;
        Oid         lcoltype = exprType(lcolnode);
        Oid         rcoltype = exprType(rcolnode);
        Node       *bestexpr;
        int         bestlocation;
        Oid         rescoltype;
        int32       rescoltypmod;
        Oid         rescolcoll;
 
        /* select common type, same as CASE et al */
        rescoltype = select_common_type(pstate,
                                        list_make2(lcolnode, rcolnode),
                                        context,
                                        &bestexpr);
        bestlocation = exprLocation(bestexpr);
 
        /*
         * Verify the coercions are actually possible.  If not, we'd fail
         * later anyway, but we want to fail now while we have sufficient
         * context to produce an error cursor position.
         *
         * For all non-UNKNOWN-type cases, we verify coercibility but we don't
         * modify the child's expression, for fear of changing the child
         * query's semantics.
         *
         * If a child expression is an UNKNOWN-type Const or Param, we want to
         * replace it with the coerced expression.  This can only happen when
         * the child is a leaf set-op node.  It's safe to replace the
         * expression because if the child query's semantics depended on the
         * type of this output column, it'd have already coerced the UNKNOWN
         * to something else.  We want to do this because (a) we want to
         * verify that a Const is valid for the target type, or resolve the
         * actual type of an UNKNOWN Param, and (b) we want to avoid
         * unnecessary discrepancies between the output type of the child
         * query and the resolved target type. Such a discrepancy would
         * disable optimization in the planner.
         *
         * If it's some other UNKNOWN-type node, eg a Var, we do nothing
         * (knowing that coerce_to_common_type would fail).  The planner is
         * sometimes able to fold an UNKNOWN Var to a constant before it has
         * to coerce the type, so failing now would just break cases that
         * might work.
         */
        if (lcoltype != UNKNOWNOID)
            lcolnode = coerce_to_common_type(pstate, lcolnode,
                                             rescoltype, context);
        else if (IsA(lcolnode, Const) ||
                 IsA(lcolnode, Param))
        {
            lcolnode = coerce_to_common_type(pstate, lcolnode,
                                             rescoltype, context);
            ltle->expr = (Expr *) lcolnode;
        }
 
        if (rcoltype != UNKNOWNOID)
            rcolnode = coerce_to_common_type(pstate, rcolnode,
                                             rescoltype, context);
        else if (IsA(rcolnode, Const) ||
                 IsA(rcolnode, Param))
        {
            rcolnode = coerce_to_common_type(pstate, rcolnode,
                                             rescoltype, context);
            rtle->expr = (Expr *) rcolnode;
        }
 
        rescoltypmod = select_common_typmod(pstate,
                                            list_make2(lcolnode, rcolnode),
                                            rescoltype);
 
        /*
         * Select common collation.  A common collation is required for all
         * set operators except UNION ALL; see SQL:2008 7.13 <query
         * expression> Syntax Rule 15c.  (If we fail to identify a common
         * collation for a UNION ALL column, the colCollations element will be
         * set to InvalidOid, which may result in a runtime error if something
         * at a higher query level wants to use the column's collation.)
         */
        rescolcoll = select_common_collation(pstate,
                                             list_make2(lcolnode, rcolnode),
                                             (op->op == SETOP_UNION && op->all));
 
        /* emit results */
        op->colTypes = lappend_oid(op->colTypes, rescoltype);
        op->colTypmods = lappend_int(op->colTypmods, rescoltypmod);
        op->colCollations = lappend_oid(op->colCollations, rescolcoll);
 
        /*
         * For all cases except UNION ALL, identify the grouping operators
         * (and, if available, sorting operators) that will be used to
         * eliminate duplicates.
         */
        if (op->op != SETOP_UNION || !op->all)
        {
            ParseCallbackState pcbstate;
 
            setup_parser_errposition_callback(&pcbstate, pstate,
                                              bestlocation);
 
            /* If it's a recursive union, we need to require hashing support. */
            op->groupClauses = lappend(op->groupClauses,
                                       makeSortGroupClauseForSetOp(rescoltype, recursive));
 
            cancel_parser_errposition_callback(&pcbstate);
        }
 
        /*
         * Construct a dummy tlist entry to return.  We use a SetToDefault
         * node for the expression, since it carries exactly the fields
         * needed, but any other expression node type would do as well.
         */
        if (targetlist)
        {
            SetToDefault *rescolnode = makeNode(SetToDefault);
            TargetEntry *restle;
 
            rescolnode->typeId = rescoltype;
            rescolnode->typeMod = rescoltypmod;
            rescolnode->collation = rescolcoll;
            rescolnode->location = bestlocation;
            restle = makeTargetEntry((Expr *) rescolnode,
                                     0, /* no need to set resno */
                                     NULL,
                                     false);
            *targetlist = lappend(*targetlist, restle);
        }
    }
}

References SetOperationStmt::all, cancel_parser_errposition_callback(), coerce_to_common_type(), ereport, errcode(), errmsg, ERROR, exprLocation(), exprType(), fb(), forboth, IsA, lappend(), lappend_int(), lappend_oid(), lfirst, list_length(), list_make2, makeNode, makeSortGroupClauseForSetOp(), makeTargetEntry(), NIL, SetOperationStmt::op, parser_errposition(), select_common_collation(), select_common_type(), select_common_typmod(), SETOP_UNION, and setup_parser_errposition_callback().

Referenced by generate_setop_from_pathqueries(), and transformSetOperationTree().

LCS_asString()

const char * LCS_asString ( LockClauseStrength  strength )

extern

Definition at line 3720 of file analyze.c.

{
    switch (strength)
    {
        case LCS_NONE:
            Assert(false);
            break;
        case LCS_FORKEYSHARE:
            return "FOR KEY SHARE";
        case LCS_FORSHARE:
            return "FOR SHARE";
        case LCS_FORNOKEYUPDATE:
            return "FOR NO KEY UPDATE";
        case LCS_FORUPDATE:
            return "FOR UPDATE";
    }
    return "FOR some";          /* shouldn't happen */
}

References Assert, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, and LCS_NONE.

Referenced by CheckSelectLocking(), grouping_planner(), make_outerjoininfo(), transformDeclareCursorStmt(), transformLockingClause(), transformSetOperationStmt(), transformSetOperationTree(), and transformValuesClause().

makeSortGroupClauseForSetOp()

SortGroupClause * makeSortGroupClauseForSetOp ( Oid  rescoltype, bool  require_hash  )

extern

Definition at line 2377 of file analyze.c.

{
    SortGroupClause *grpcl = makeNode(SortGroupClause);
    Oid         sortop;
    Oid         eqop;
    bool        hashable;
 
    /* determine the eqop and optional sortop */
    get_sort_group_operators(rescoltype,
                             false, true, false,
                             &sortop, &eqop, NULL,
                             &hashable);
 
    /*
     * The type cache doesn't believe that record is hashable (see
     * cache_record_field_properties()), but if the caller really needs hash
     * support, we can assume it does.  Worst case, if any components of the
     * record don't support hashing, we will fail at execution.
     */
    if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
        hashable = true;
 
    /* we don't have a tlist yet, so can't assign sortgrouprefs */
    grpcl->tleSortGroupRef = 0;
    grpcl->eqop = eqop;
    grpcl->sortop = sortop;
    grpcl->reverse_sort = false;    /* Sort-op is "less than", or InvalidOid */
    grpcl->nulls_first = false; /* OK with or without sortop */
    grpcl->hashable = hashable;
 
    return grpcl;
}

References fb(), get_sort_group_operators(), and makeNode.

Referenced by constructSetOpTargetlist(), and rewriteSearchAndCycle().

parse_analyze_fixedparams()

Query * parse_analyze_fixedparams ( RawStmt *  parseTree, const char *  sourceText, const Oid *  paramTypes, int  numParams, QueryEnvironment *  queryEnv  )

extern

Definition at line 127 of file analyze.c.

{
    ParseState *pstate = make_parsestate(NULL);
    Query      *query;
    JumbleState *jstate = NULL;
 
    Assert(sourceText != NULL); /* required as of 8.4 */
 
    pstate->p_sourcetext = sourceText;
 
    if (numParams > 0)
        setup_parse_fixed_parameters(pstate, paramTypes, numParams);
 
    pstate->p_queryEnv = queryEnv;
 
    query = transformTopLevelStmt(pstate, parseTree);
 
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    free_parsestate(pstate);
 
    pgstat_report_query_id(query->queryId, false);
 
    return query;
}

References Assert, fb(), free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, setup_parse_fixed_parameters(), and transformTopLevelStmt().

Referenced by DefineView(), and pg_analyze_and_rewrite_fixedparams().

parse_analyze_varparams()

Query * parse_analyze_varparams ( RawStmt *  parseTree, const char *  sourceText, Oid **  paramTypes, int *  numParams, QueryEnvironment *  queryEnv  )

extern

Definition at line 167 of file analyze.c.

{
    ParseState *pstate = make_parsestate(NULL);
    Query      *query;
    JumbleState *jstate = NULL;
 
    Assert(sourceText != NULL); /* required as of 8.4 */
 
    pstate->p_sourcetext = sourceText;
 
    setup_parse_variable_parameters(pstate, paramTypes, numParams);
 
    pstate->p_queryEnv = queryEnv;
 
    query = transformTopLevelStmt(pstate, parseTree);
 
    /* make sure all is well with parameter types */
    check_variable_parameters(pstate, query);
 
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    free_parsestate(pstate);
 
    pgstat_report_query_id(query->queryId, false);
 
    return query;
}

References Assert, check_variable_parameters(), fb(), free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, setup_parse_variable_parameters(), and transformTopLevelStmt().

Referenced by pg_analyze_and_rewrite_varparams().

parse_analyze_withcb()

Query * parse_analyze_withcb ( RawStmt *  parseTree, const char *  sourceText, ParserSetupHook  parserSetup, void *  parserSetupArg, QueryEnvironment *  queryEnv  )

extern

Definition at line 208 of file analyze.c.

{
    ParseState *pstate = make_parsestate(NULL);
    Query      *query;
    JumbleState *jstate = NULL;
 
    Assert(sourceText != NULL); /* required as of 8.4 */
 
    pstate->p_sourcetext = sourceText;
    pstate->p_queryEnv = queryEnv;
    (*parserSetup) (pstate, parserSetupArg);
 
    query = transformTopLevelStmt(pstate, parseTree);
 
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    free_parsestate(pstate);
 
    pgstat_report_query_id(query->queryId, false);
 
    return query;
}

References Assert, fb(), free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, and transformTopLevelStmt().

Referenced by pg_analyze_and_rewrite_withcb().

parse_sub_analyze()

Query * parse_sub_analyze ( Node *  parseTree, ParseState *  parentParseState, CommonTableExpr *  parentCTE, bool  locked_from_parent, bool  resolve_unknowns  )

extern

Definition at line 244 of file analyze.c.

{
    ParseState *pstate = make_parsestate(parentParseState);
    Query      *query;
 
    pstate->p_parent_cte = parentCTE;
    pstate->p_locked_from_parent = locked_from_parent;
    pstate->p_resolve_unknowns = resolve_unknowns;
 
    query = transformStmt(pstate, parseTree);
 
    free_parsestate(pstate);
 
    return query;
}

References fb(), free_parsestate(), make_parsestate(), ParseState::p_locked_from_parent, ParseState::p_parent_cte, ParseState::p_resolve_unknowns, and transformStmt().

Referenced by analyzeCTE(), transformRangeSubselect(), transformSetOperationTree(), and transformSubLink().

query_requires_rewrite_plan()

bool query_requires_rewrite_plan ( Query *  query )

extern

Definition at line 542 of file analyze.c.

{
    bool        result;
 
    if (query->commandType != CMD_UTILITY)
    {
        /* All optimizable statements require rewriting/planning */
        result = true;
    }
    else
    {
        /* This list should match stmt_requires_parse_analysis() */
        switch (nodeTag(query->utilityStmt))
        {
            case T_DeclareCursorStmt:
            case T_ExplainStmt:
            case T_CreateTableAsStmt:
            case T_CallStmt:
                result = true;
                break;
            default:
                result = false;
                break;
        }
    }
    return result;
}

References CMD_UTILITY, Query::commandType, fb(), nodeTag, result, and Query::utilityStmt.

Referenced by BuildingPlanRequiresSnapshot(), and StmtPlanRequiresRevalidation().

stmt_requires_parse_analysis()

bool stmt_requires_parse_analysis ( RawStmt *  parseTree )

extern

Definition at line 469 of file analyze.c.

{
    bool        result;
 
    switch (nodeTag(parseTree->stmt))
    {
            /*
             * Optimizable statements
             */
        case T_InsertStmt:
        case T_DeleteStmt:
        case T_UpdateStmt:
        case T_MergeStmt:
        case T_SelectStmt:
        case T_ReturnStmt:
        case T_PLAssignStmt:
            result = true;
            break;
 
            /*
             * Special cases
             */
        case T_DeclareCursorStmt:
        case T_ExplainStmt:
        case T_CreateTableAsStmt:
        case T_CallStmt:
            result = true;
            break;
 
        default:
            /* all other statements just get wrapped in a CMD_UTILITY Query */
            result = false;
            break;
    }
 
    return result;
}

References fb(), nodeTag, and result.

Referenced by analyze_requires_snapshot(), and StmtPlanRequiresRevalidation().

transformInsertRow()

List * transformInsertRow ( ParseState *  pstate, List *  exprlist, List *  stmtcols, List *  icolumns, List *  attrnos, bool  strip_indirection  )

extern

Definition at line 1102 of file analyze.c.

{
    List       *result;
    ListCell   *lc;
    ListCell   *icols;
    ListCell   *attnos;
 
    /*
     * Check length of expr list.  It must not have more expressions than
     * there are target columns.  We allow fewer, but only if no explicit
     * columns list was given (the remaining columns are implicitly
     * defaulted).  Note we must check this *after* transformation because
     * that could expand '*' into multiple items.
     */
    if (list_length(exprlist) > list_length(icolumns))
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("INSERT has more expressions than target columns"),
                 parser_errposition(pstate,
                                    exprLocation(list_nth(exprlist,
                                                          list_length(icolumns))))));
    if (stmtcols != NIL &&
        list_length(exprlist) < list_length(icolumns))
    {
        /*
         * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
         * where the user accidentally created a RowExpr instead of separate
         * columns.  Add a suitable hint if that seems to be the problem,
         * because the main error message is quite misleading for this case.
         * (If there's no stmtcols, you'll get something about data type
         * mismatch, which is less misleading so we don't worry about giving a
         * hint in that case.)
         */
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("INSERT has more target columns than expressions"),
                 ((list_length(exprlist) == 1 &&
                   count_rowexpr_columns(pstate, linitial(exprlist)) ==
                   list_length(icolumns)) ?
                  errhint("The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?") : 0),
                 parser_errposition(pstate,
                                    exprLocation(list_nth(icolumns,
                                                          list_length(exprlist))))));
    }
 
    /*
     * Prepare columns for assignment to target table.
     */
    result = NIL;
    forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        ResTarget  *col = lfirst_node(ResTarget, icols);
        int         attno = lfirst_int(attnos);
 
        expr = transformAssignedExpr(pstate, expr,
                                     EXPR_KIND_INSERT_TARGET,
                                     col->name,
                                     attno,
                                     col->indirection,
                                     col->location);
 
        if (strip_indirection)
        {
            /*
             * We need to remove top-level FieldStores and SubscriptingRefs,
             * as well as any CoerceToDomain appearing above one of those ---
             * but not a CoerceToDomain that isn't above one of those.
             */
            while (expr)
            {
                Expr       *subexpr = expr;
 
                while (IsA(subexpr, CoerceToDomain))
                {
                    subexpr = ((CoerceToDomain *) subexpr)->arg;
                }
                if (IsA(subexpr, FieldStore))
                {
                    FieldStore *fstore = (FieldStore *) subexpr;
 
                    expr = (Expr *) linitial(fstore->newvals);
                }
                else if (IsA(subexpr, SubscriptingRef))
                {
                    SubscriptingRef *sbsref = (SubscriptingRef *) subexpr;
 
                    if (sbsref->refassgnexpr == NULL)
                        break;
 
                    expr = sbsref->refassgnexpr;
                }
                else
                    break;
            }
        }
 
        result = lappend(result, expr);
    }
 
    return result;
}

References count_rowexpr_columns(), ereport, errcode(), errhint(), errmsg, ERROR, EXPR_KIND_INSERT_TARGET, exprLocation(), fb(), forthree, IsA, lappend(), lfirst, lfirst_int, lfirst_node, linitial, list_length(), list_nth(), FieldStore::newvals, NIL, parser_errposition(), SubscriptingRef::refassgnexpr, result, and transformAssignedExpr().

Referenced by transformInsertStmt(), and transformMergeStmt().

transformReturningClause()

void transformReturningClause ( ParseState *  pstate, Query *  qry, ReturningClause *  returningClause, ParseExprKind  exprKind  )

extern

Definition at line 3067 of file analyze.c.

{
    int         save_nslen = list_length(pstate->p_namespace);
    int         save_next_resno;
 
    if (returningClause == NULL)
        return;                 /* nothing to do */
 
    /*
     * Scan RETURNING WITH(...) options for OLD/NEW alias names.  Complain if
     * there is any conflict with existing relations.
     */
    foreach_node(ReturningOption, option, returningClause->options)
    {
        switch (option->option)
        {
            case RETURNING_OPTION_OLD:
                if (qry->returningOldAlias != NULL)
                    ereport(ERROR,
                            errcode(ERRCODE_SYNTAX_ERROR),
                    /* translator: %s is OLD or NEW */
                            errmsg("%s cannot be specified multiple times", "OLD"),
                            parser_errposition(pstate, option->location));
                qry->returningOldAlias = option->value;
                break;
 
            case RETURNING_OPTION_NEW:
                if (qry->returningNewAlias != NULL)
                    ereport(ERROR,
                            errcode(ERRCODE_SYNTAX_ERROR),
                    /* translator: %s is OLD or NEW */
                            errmsg("%s cannot be specified multiple times", "NEW"),
                            parser_errposition(pstate, option->location));
                qry->returningNewAlias = option->value;
                break;
 
            default:
                elog(ERROR, "unrecognized returning option: %d", option->option);
        }
 
        if (refnameNamespaceItem(pstate, NULL, option->value, -1, NULL) != NULL)
            ereport(ERROR,
                    errcode(ERRCODE_DUPLICATE_ALIAS),
                    errmsg("table name \"%s\" specified more than once",
                           option->value),
                    parser_errposition(pstate, option->location));
 
        addNSItemForReturning(pstate, option->value,
                              option->option == RETURNING_OPTION_OLD ?
                              VAR_RETURNING_OLD : VAR_RETURNING_NEW);
    }
 
    /*
     * If OLD/NEW alias names weren't explicitly specified, use "old"/"new"
     * unless masked by existing relations.
     */
    if (qry->returningOldAlias == NULL &&
        refnameNamespaceItem(pstate, NULL, "old", -1, NULL) == NULL)
    {
        qry->returningOldAlias = "old";
        addNSItemForReturning(pstate, "old", VAR_RETURNING_OLD);
    }
    if (qry->returningNewAlias == NULL &&
        refnameNamespaceItem(pstate, NULL, "new", -1, NULL) == NULL)
    {
        qry->returningNewAlias = "new";
        addNSItemForReturning(pstate, "new", VAR_RETURNING_NEW);
    }
 
    /*
     * We need to assign resnos starting at one in the RETURNING list. Save
     * and restore the main tlist's value of p_next_resno, just in case
     * someone looks at it later (probably won't happen).
     */
    save_next_resno = pstate->p_next_resno;
    pstate->p_next_resno = 1;
 
    /* transform RETURNING expressions identically to a SELECT targetlist */
    qry->returningList = transformTargetList(pstate,
                                             returningClause->exprs,
                                             exprKind);
 
    /*
     * Complain if the nonempty tlist expanded to nothing (which is possible
     * if it contains only a star-expansion of a zero-column table).  If we
     * allow this, the parsed Query will look like it didn't have RETURNING,
     * with results that would probably surprise the user.
     */
    if (qry->returningList == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("RETURNING must have at least one column"),
                 parser_errposition(pstate,
                                    exprLocation(linitial(returningClause->exprs)))));
 
    /* mark column origins */
    markTargetListOrigins(pstate, qry->returningList);
 
    /* resolve any still-unresolved output columns as being type text */
    if (pstate->p_resolve_unknowns)
        resolveTargetListUnknowns(pstate, qry->returningList);
 
    /* restore state */
    pstate->p_namespace = list_truncate(pstate->p_namespace, save_nslen);
    pstate->p_next_resno = save_next_resno;
}

References addNSItemForReturning(), elog, ereport, errcode(), errmsg, ERROR, exprLocation(), ReturningClause::exprs, fb(), foreach_node, linitial, list_length(), list_truncate(), markTargetListOrigins(), NIL, ReturningClause::options, ParseState::p_namespace, ParseState::p_next_resno, ParseState::p_resolve_unknowns, parser_errposition(), refnameNamespaceItem(), resolveTargetListUnknowns(), RETURNING_OPTION_NEW, RETURNING_OPTION_OLD, Query::returningList, transformTargetList(), VAR_RETURNING_NEW, and VAR_RETURNING_OLD.

Referenced by transformDeleteStmt(), transformInsertStmt(), transformMergeStmt(), and transformUpdateStmt().

transformStmt()

Query * transformStmt ( ParseState *  pstate, Node *  parseTree  )

extern

Definition at line 334 of file analyze.c.

{
    Query      *result;
 
#ifdef DEBUG_NODE_TESTS_ENABLED
 
    /*
     * We apply debug_raw_expression_coverage_test testing to basic DML
     * statements; we can't just run it on everything because
     * raw_expression_tree_walker() doesn't claim to handle utility
     * statements.
     */
    if (Debug_raw_expression_coverage_test)
    {
        switch (nodeTag(parseTree))
        {
            case T_SelectStmt:
            case T_InsertStmt:
            case T_UpdateStmt:
            case T_DeleteStmt:
            case T_MergeStmt:
                (void) test_raw_expression_coverage(parseTree, NULL);
                break;
            default:
                break;
        }
    }
#endif                          /* DEBUG_NODE_TESTS_ENABLED */
 
    /*
     * Caution: when changing the set of statement types that have non-default
     * processing here, see also stmt_requires_parse_analysis() and
     * analyze_requires_snapshot().
     */
    switch (nodeTag(parseTree))
    {
            /*
             * Optimizable statements
             */
        case T_InsertStmt:
            result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
            break;
 
        case T_DeleteStmt:
            result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree);
            break;
 
        case T_UpdateStmt:
            result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree);
            break;
 
        case T_MergeStmt:
            result = transformMergeStmt(pstate, (MergeStmt *) parseTree);
            break;
 
        case T_SelectStmt:
            {
                SelectStmt *n = (SelectStmt *) parseTree;
 
                if (n->valuesLists)
                    result = transformValuesClause(pstate, n);
                else if (n->op == SETOP_NONE)
                    result = transformSelectStmt(pstate, n, NULL);
                else
                    result = transformSetOperationStmt(pstate, n);
            }
            break;
 
        case T_ReturnStmt:
            result = transformReturnStmt(pstate, (ReturnStmt *) parseTree);
            break;
 
        case T_PLAssignStmt:
            result = transformPLAssignStmt(pstate,
                                           (PLAssignStmt *) parseTree);
            break;
 
            /*
             * Special cases
             */
        case T_DeclareCursorStmt:
            result = transformDeclareCursorStmt(pstate,
                                                (DeclareCursorStmt *) parseTree);
            break;
 
        case T_ExplainStmt:
            result = transformExplainStmt(pstate,
                                          (ExplainStmt *) parseTree);
            break;
 
        case T_CreateTableAsStmt:
            result = transformCreateTableAsStmt(pstate,
                                                (CreateTableAsStmt *) parseTree);
            break;
 
        case T_CallStmt:
            result = transformCallStmt(pstate,
                                       (CallStmt *) parseTree);
            break;
 
        default:
 
            /*
             * other statements don't require any transformation; just return
             * the original parsetree with a Query node plastered on top.
             */
            result = makeNode(Query);
            result->commandType = CMD_UTILITY;
            result->utilityStmt = parseTree;
            break;
    }
 
    /* Mark as original query until we learn differently */
    result->querySource = QSRC_ORIGINAL;
    result->canSetTag = true;
 
    return result;
}

References CMD_UTILITY, fb(), makeNode, nodeTag, SelectStmt::op, QSRC_ORIGINAL, result, SETOP_NONE, transformCallStmt(), transformCreateTableAsStmt(), transformDeclareCursorStmt(), transformDeleteStmt(), transformExplainStmt(), transformInsertStmt(), transformMergeStmt(), transformPLAssignStmt(), transformReturnStmt(), transformSelectStmt(), transformSetOperationStmt(), transformUpdateStmt(), transformValuesClause(), and SelectStmt::valuesLists.

Referenced by interpret_AS_clause(), parse_sub_analyze(), transformCreateTableAsStmt(), transformDeclareCursorStmt(), transformInsertStmt(), transformJsonArrayQueryConstructor(), transformOptionalSelectInto(), and transformRuleStmt().

transformTopLevelStmt()

Query * transformTopLevelStmt ( ParseState *  pstate, RawStmt *  parseTree  )

extern

Definition at line 271 of file analyze.c.

{
    Query      *result;
 
    /* We're at top level, so allow SELECT INTO */
    result = transformOptionalSelectInto(pstate, parseTree->stmt);
 
    result->stmt_location = parseTree->stmt_location;
    result->stmt_len = parseTree->stmt_len;
 
    return result;
}

References fb(), result, and transformOptionalSelectInto().

Referenced by inline_function(), parse_analyze_fixedparams(), parse_analyze_varparams(), and parse_analyze_withcb().

transformUpdateTargetList()

List * transformUpdateTargetList ( ParseState *  pstate, List *  origTlist, ForPortionOfExpr *  forPortionOf  )

extern

Definition at line 2939 of file analyze.c.

{
    List       *tlist = NIL;
    RTEPermissionInfo *target_perminfo;
    ListCell   *orig_tl;
    ListCell   *tl;
 
    tlist = transformTargetList(pstate, origTlist,
                                EXPR_KIND_UPDATE_SOURCE);
 
    /* Prepare to assign non-conflicting resnos to resjunk attributes */
    if (pstate->p_next_resno <= RelationGetNumberOfAttributes(pstate->p_target_relation))
        pstate->p_next_resno = RelationGetNumberOfAttributes(pstate->p_target_relation) + 1;
 
    /* Prepare non-junk columns for assignment to target table */
    target_perminfo = pstate->p_target_nsitem->p_perminfo;
    orig_tl = list_head(origTlist);
 
    foreach(tl, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(tl);
        ResTarget  *origTarget;
        int         attrno;
 
        if (tle->resjunk)
        {
            /*
             * Resjunk nodes need no additional processing, but be sure they
             * have resnos that do not match any target columns; else rewriter
             * or planner might get confused.  They don't need a resname
             * either.
             */
            tle->resno = (AttrNumber) pstate->p_next_resno++;
            tle->resname = NULL;
            continue;
        }
        if (orig_tl == NULL)
            elog(ERROR, "UPDATE target count mismatch --- internal error");
        origTarget = lfirst_node(ResTarget, orig_tl);
 
        attrno = attnameAttNum(pstate->p_target_relation,
                               origTarget->name, true);
        if (attrno == InvalidAttrNumber)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            origTarget->name,
                            RelationGetRelationName(pstate->p_target_relation)),
                     (origTarget->indirection != NIL &&
                      strcmp(origTarget->name, pstate->p_target_nsitem->p_names->aliasname) == 0) ?
                     errhint("SET target columns cannot be qualified with the relation name.") : 0,
                     parser_errposition(pstate, origTarget->location)));
 
        /*
         * If this is a FOR PORTION OF update, forbid directly setting the
         * range column, since that would conflict with the implicit updates.
         */
        if (forPortionOf != NULL)
        {
            if (attrno == forPortionOf->rangeVar->varattno)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot update column \"%s\" because it is used in FOR PORTION OF",
                                origTarget->name),
                         parser_errposition(pstate, origTarget->location)));
        }
 
        updateTargetListEntry(pstate, tle, origTarget->name,
                              attrno,
                              origTarget->indirection,
                              origTarget->location);
 
        /* Mark the target column as requiring update permissions */
        target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
                                                      attrno - FirstLowInvalidHeapAttributeNumber);
 
        orig_tl = lnext(origTlist, orig_tl);
    }
    if (orig_tl != NULL)
        elog(ERROR, "UPDATE target count mismatch --- internal error");
 
    return tlist;
}

References Alias::aliasname, attnameAttNum(), bms_add_member(), elog, ereport, errcode(), errhint(), errmsg, ERROR, EXPR_KIND_UPDATE_SOURCE, fb(), FirstLowInvalidHeapAttributeNumber, InvalidAttrNumber, lfirst, lfirst_node, list_head(), lnext(), NIL, ParseNamespaceItem::p_names, ParseState::p_next_resno, ParseNamespaceItem::p_perminfo, ParseState::p_target_nsitem, ParseState::p_target_relation, parser_errposition(), ForPortionOfExpr::rangeVar, RelationGetNumberOfAttributes, RelationGetRelationName, transformTargetList(), updateTargetListEntry(), and Var::varattno.

Referenced by transformMergeStmt(), transformOnConflictClause(), and transformUpdateStmt().

Variable Documentation

post_parse_analyze_hook

PGDLLIMPORT post_parse_analyze_hook_type post_parse_analyze_hook

extern

Definition at line 74 of file analyze.c.

Referenced by _PG_init(), ExecCreateTableAs(), ExplainOneUtility(), ExplainQuery(), parse_analyze_fixedparams(), parse_analyze_varparams(), parse_analyze_withcb(), and PerformCursorOpen().