#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:

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)

Query *	transformTopLevelStmt (ParseState pstate, RawStmt parseTree)

Query *	transformStmt (ParseState pstate, Node 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 431 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_PLAssignStmt:
             result = true;
             break;
  
             /*
              * Special cases
              */
         case T_DeclareCursorStmt:
         case T_ExplainStmt:
         case T_CreateTableAsStmt:
             /* yes, because we must analyze the contained statement */
             result = true;
             break;
  
         default:
             /* other utility statements don't have any real parse analysis */
             result = false;
             break;
     }
  
     return result;
 }

References nodeTag, and RawStmt::stmt.

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 3475 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 1177 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 3184 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 3159 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 1907 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->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::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 107 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, sourceText);
  
     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 147 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, sourceText);
  
     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 188 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, sourceText);
  
     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 224 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().

◆ transformInsertRow()

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

Definition at line 971 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)
         {
             while (expr)
             {
                 if (IsA(expr, FieldStore))
                 {
                     FieldStore *fstore = (FieldStore *) expr;
  
                     expr = (Expr *) linitial(fstore->newvals);
                 }
                 else if (IsA(expr, SubscriptingRef))
                 {
                     SubscriptingRef *sbsref = (SubscriptingRef *) expr;
  
                     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().

◆ transformStmt()

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

Definition at line 314 of file analyze.c.

 {
     Query      *result;
  
     /*
      * We apply 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.
      */
 #ifdef 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                          /* RAW_EXPRESSION_COVERAGE_TEST */
  
     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;
  
     return result;
 }

References CMD_UTILITY, Query::commandType, makeNode, nodeTag, SelectStmt::op, QSRC_ORIGINAL, SETOP_NONE, 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 251 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 RawStmt::stmt, RawStmt::stmt_len, Query::stmt_location, 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 2435 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)),
                      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 attnameAttNum(), bms_add_member(), elog(), ereport, errcode(), errmsg(), ERROR, EXPR_KIND_UPDATE_SOURCE, FirstLowInvalidHeapAttributeNumber, ResTarget::indirection, InvalidAttrNumber, lfirst, lfirst_node, list_head(), lnext(), ResTarget::location, ResTarget::name, NIL, 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 60 of file analyze.c.

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

Typedefs

Functions

Variables