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, 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)
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)
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)

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, JumbleState *jstate)

Definition at line 22 of file analyze.h.

Function Documentation

analyze_requires_snapshot()

bool analyze_requires_snapshot

(

RawStmt *

parseTree

)

Definition at line 576 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 stmt_requires_parse_analysis().

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

applyLockingClause()

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

Definition at line 3723 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, 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
	)

Definition at line 1315 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 InvalidAttrNumber, InvalidOid, lappend(), makeNullConst(), makeTargetEntry(), makeVar(), name, NameStr, NIL, pstrdup(), RelationData::rd_att, RelationData::rd_rel, RelationGetNumberOfAttributes, and TupleDescAttr().

Referenced by rewriteTargetView(), and transformOnConflictClause().

CheckSelectLocking()

void CheckSelectLocking	(	Query *	qry,
		LockClauseStrength	strength
	)

Definition at line 3432 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, Query::groupClause, Query::groupingSets, Query::havingQual, LCS_asString(), LCS_NONE, NIL, and Query::setOperations.

Referenced by preprocess_rowmarks(), and transformLockingClause().

LCS_asString()

const char * LCS_asString

(

LockClauseStrength

strength

)

Definition at line 3407 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
	)

Definition at line 2046 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 SortGroupClause::eqop, get_sort_group_operators(), makeNode, SortGroupClause::nulls_first, SortGroupClause::reverse_sort, SortGroupClause::sortop, and SortGroupClause::tleSortGroupRef.

Referenced by rewriteSearchAndCycle(), and transformSetOperationTree().

parse_analyze_fixedparams()

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

Definition at line 105 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, 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
	)

Definition at line 145 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(), 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
	)

Definition at line 186 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, 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
	)

Definition at line 222 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 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().

stmt_requires_parse_analysis()

bool stmt_requires_parse_analysis

(

RawStmt *

parseTree

)

Definition at line 532 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 nodeTag, and RawStmt::stmt.

Referenced by analyze_requires_snapshot().

transformInsertRow()

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

Definition at line 1098 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(), forthree, ResTarget::indirection, IsA, lappend(), lfirst, lfirst_int, lfirst_node, linitial, list_length(), list_nth(), ResTarget::location, ResTarget::name, FieldStore::newvals, NIL, parser_errposition(), SubscriptingRef::refassgnexpr, and transformAssignedExpr().

Referenced by transformInsertStmt(), and transformMergeStmt().

transformReturningClause()

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

Definition at line 2691 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, 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(), transformMergeStmt(), and transformUpdateStmt().

transformStmt()

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

Definition at line 396 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);
                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 = (Node *) parseTree;
            break;
    }
 
    /* Mark as original query until we learn differently */
    result->querySource = QSRC_ORIGINAL;
    result->canSetTag = true;
    setQueryLocationAndLength(pstate, result, parseTree);
 
    return result;
}

References CMD_UTILITY, Query::commandType, makeNode, nodeTag, SelectStmt::op, QSRC_ORIGINAL, SETOP_NONE, setQueryLocationAndLength(), transformCallStmt(), transformCreateTableAsStmt(), transformDeclareCursorStmt(), transformDeleteStmt(), transformExplainStmt(), transformInsertStmt(), transformMergeStmt(), transformPLAssignStmt(), transformReturnStmt(), transformSelectStmt(), transformSetOperationStmt(), transformUpdateStmt(), transformValuesClause(), Query::utilityStmt, 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
	)

Definition at line 332 of file analyze.c.

{
    Query      *result;
 
    /* Store RawStmt's length and location in pstate */
    pstate->p_stmt_len = parseTree->stmt_len;
    pstate->p_stmt_location = parseTree->stmt_location;
 
    /* We're at top level, so allow SELECT INTO */
    result = transformOptionalSelectInto(pstate, parseTree->stmt);
 
    return result;
}

References ParseState::p_stmt_len, ParseState::p_stmt_location, RawStmt::stmt, RawStmt::stmt_len, RawStmt::stmt_location, and transformOptionalSelectInto().

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

transformUpdateTargetList()

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

Definition at line 2576 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)));
 
        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, FirstLowInvalidHeapAttributeNumber, ResTarget::indirection, InvalidAttrNumber, lfirst, lfirst_node, list_head(), lnext(), ResTarget::location, ResTarget::name, NIL, ParseNamespaceItem::p_names, ParseState::p_next_resno, ParseNamespaceItem::p_perminfo, ParseState::p_target_nsitem, ParseState::p_target_relation, parser_errposition(), RelationGetNumberOfAttributes, RelationGetRelationName, TargetEntry::resno, transformTargetList(), RTEPermissionInfo::updatedCols, and updateTargetListEntry().

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 59 of file analyze.c.

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