PostgreSQL Source Code  git master
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

Queryparse_analyze_fixedparams (RawStmt *parseTree, const char *sourceText, const Oid *paramTypes, int numParams, QueryEnvironment *queryEnv)
 
Queryparse_analyze_varparams (RawStmt *parseTree, const char *sourceText, Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv)
 
Queryparse_analyze_withcb (RawStmt *parseTree, const char *sourceText, ParserSetupHook parserSetup, void *parserSetupArg, QueryEnvironment *queryEnv)
 
Queryparse_sub_analyze (Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
 
ListtransformInsertRow (ParseState *pstate, List *exprlist, List *stmtcols, List *icolumns, List *attrnos, bool strip_indirection)
 
ListtransformUpdateTargetList (ParseState *pstate, List *origTlist)
 
QuerytransformTopLevelStmt (ParseState *pstate, RawStmt *parseTree)
 
QuerytransformStmt (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)
 
ListBuildOnConflictExcludedTargetlist (Relation targetrel, Index exclRelIndex)
 
SortGroupClausemakeSortGroupClauseForSetOp (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 488 of file analyze.c.

489 {
490  /*
491  * Currently, this should return true in exactly the same cases that
492  * stmt_requires_parse_analysis() does, so we just invoke that function
493  * rather than duplicating it. We keep the two entry points separate for
494  * clarity of callers, since from the callers' standpoint these are
495  * different conditions.
496  *
497  * While there may someday be a statement type for which transformStmt()
498  * does something nontrivial and yet no snapshot is needed for that
499  * processing, it seems likely that making such a choice would be fragile.
500  * If you want to install an exception, document the reasoning for it in a
501  * comment.
502  */
503  return stmt_requires_parse_analysis(parseTree);
504 }
bool stmt_requires_parse_analysis(RawStmt *parseTree)
Definition: analyze.c:444

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

3516 {
3517  RowMarkClause *rc;
3518 
3519  Assert(strength != LCS_NONE); /* else caller error */
3520 
3521  /* If it's an explicit clause, make sure hasForUpdate gets set */
3522  if (!pushedDown)
3523  qry->hasForUpdate = true;
3524 
3525  /* Check for pre-existing entry for same rtindex */
3526  if ((rc = get_parse_rowmark(qry, rtindex)) != NULL)
3527  {
3528  /*
3529  * If the same RTE is specified with more than one locking strength,
3530  * use the strongest. (Reasonable, since you can't take both a shared
3531  * and exclusive lock at the same time; it'll end up being exclusive
3532  * anyway.)
3533  *
3534  * Similarly, if the same RTE is specified with more than one lock
3535  * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
3536  * turn wins over waiting for the lock (the default). This is a bit
3537  * more debatable but raising an error doesn't seem helpful. (Consider
3538  * for instance SELECT FOR UPDATE NOWAIT from a view that internally
3539  * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP
3540  * LOCKED is reasonable since the former throws an error in case of
3541  * coming across a locked tuple, which may be undesirable in some
3542  * cases but it seems better than silently returning inconsistent
3543  * results.
3544  *
3545  * And of course pushedDown becomes false if any clause is explicit.
3546  */
3547  rc->strength = Max(rc->strength, strength);
3548  rc->waitPolicy = Max(rc->waitPolicy, waitPolicy);
3549  rc->pushedDown &= pushedDown;
3550  return;
3551  }
3552 
3553  /* Make a new RowMarkClause */
3554  rc = makeNode(RowMarkClause);
3555  rc->rti = rtindex;
3556  rc->strength = strength;
3557  rc->waitPolicy = waitPolicy;
3558  rc->pushedDown = pushedDown;
3559  qry->rowMarks = lappend(qry->rowMarks, rc);
3560 }
#define Max(x, y)
Definition: c.h:987
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
Definition: list.c:338
@ LCS_NONE
Definition: lockoptions.h:23
#define makeNode(_type_)
Definition: nodes.h:176
RowMarkClause * get_parse_rowmark(Query *qry, Index rtindex)
List * rowMarks
Definition: parsenodes.h:207
LockClauseStrength strength
Definition: parsenodes.h:1528
LockWaitPolicy waitPolicy
Definition: parsenodes.h:1529

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

1217 {
1218  List *result = NIL;
1219  int attno;
1220  Var *var;
1221  TargetEntry *te;
1222 
1223  /*
1224  * Note that resnos of the tlist must correspond to attnos of the
1225  * underlying relation, hence we need entries for dropped columns too.
1226  */
1227  for (attno = 0; attno < RelationGetNumberOfAttributes(targetrel); attno++)
1228  {
1229  Form_pg_attribute attr = TupleDescAttr(targetrel->rd_att, attno);
1230  char *name;
1231 
1232  if (attr->attisdropped)
1233  {
1234  /*
1235  * can't use atttypid here, but it doesn't really matter what type
1236  * the Const claims to be.
1237  */
1238  var = (Var *) makeNullConst(INT4OID, -1, InvalidOid);
1239  name = NULL;
1240  }
1241  else
1242  {
1243  var = makeVar(exclRelIndex, attno + 1,
1244  attr->atttypid, attr->atttypmod,
1245  attr->attcollation,
1246  0);
1247  name = pstrdup(NameStr(attr->attname));
1248  }
1249 
1250  te = makeTargetEntry((Expr *) var,
1251  attno + 1,
1252  name,
1253  false);
1254 
1255  result = lappend(result, te);
1256  }
1257 
1258  /*
1259  * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like
1260  * the other entries in the EXCLUDED tlist, its resno must match the Var's
1261  * varattno, else the wrong things happen while resolving references in
1262  * setrefs.c. This is against normal conventions for targetlists, but
1263  * it's okay since we don't use this as a real tlist.
1264  */
1265  var = makeVar(exclRelIndex, InvalidAttrNumber,
1266  targetrel->rd_rel->reltype,
1267  -1, InvalidOid, 0);
1268  te = makeTargetEntry((Expr *) var, InvalidAttrNumber, NULL, true);
1269  result = lappend(result, te);
1270 
1271  return result;
1272 }
#define InvalidAttrNumber
Definition: attnum.h:23
#define NameStr(name)
Definition: c.h:735
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:241
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition: makefuncs.c:340
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition: makefuncs.c:67
char * pstrdup(const char *in)
Definition: mcxt.c:1644
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
#define NIL
Definition: pg_list.h:68
#define InvalidOid
Definition: postgres_ext.h:36
#define RelationGetNumberOfAttributes(relation)
Definition: rel.h:510
Definition: pg_list.h:54
TupleDesc rd_att
Definition: rel.h:112
Form_pg_class rd_rel
Definition: rel.h:111
Definition: primnodes.h:234
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
const char * name

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

3223 {
3224  Assert(strength != LCS_NONE); /* else caller error */
3225 
3226  if (qry->setOperations)
3227  ereport(ERROR,
3228  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3229  /*------
3230  translator: %s is a SQL row locking clause such as FOR UPDATE */
3231  errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
3232  LCS_asString(strength))));
3233  if (qry->distinctClause != NIL)
3234  ereport(ERROR,
3235  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3236  /*------
3237  translator: %s is a SQL row locking clause such as FOR UPDATE */
3238  errmsg("%s is not allowed with DISTINCT clause",
3239  LCS_asString(strength))));
3240  if (qry->groupClause != NIL || qry->groupingSets != NIL)
3241  ereport(ERROR,
3242  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3243  /*------
3244  translator: %s is a SQL row locking clause such as FOR UPDATE */
3245  errmsg("%s is not allowed with GROUP BY clause",
3246  LCS_asString(strength))));
3247  if (qry->havingQual != NULL)
3248  ereport(ERROR,
3249  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3250  /*------
3251  translator: %s is a SQL row locking clause such as FOR UPDATE */
3252  errmsg("%s is not allowed with HAVING clause",
3253  LCS_asString(strength))));
3254  if (qry->hasAggs)
3255  ereport(ERROR,
3256  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3257  /*------
3258  translator: %s is a SQL row locking clause such as FOR UPDATE */
3259  errmsg("%s is not allowed with aggregate functions",
3260  LCS_asString(strength))));
3261  if (qry->hasWindowFuncs)
3262  ereport(ERROR,
3263  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3264  /*------
3265  translator: %s is a SQL row locking clause such as FOR UPDATE */
3266  errmsg("%s is not allowed with window functions",
3267  LCS_asString(strength))));
3268  if (qry->hasTargetSRFs)
3269  ereport(ERROR,
3270  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3271  /*------
3272  translator: %s is a SQL row locking clause such as FOR UPDATE */
3273  errmsg("%s is not allowed with set-returning functions in the target list",
3274  LCS_asString(strength))));
3275 }
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
const char * LCS_asString(LockClauseStrength strength)
Definition: analyze.c:3197
Node * setOperations
Definition: parsenodes.h:209
List * groupClause
Definition: parsenodes.h:190
Node * havingQual
Definition: parsenodes.h:195
List * groupingSets
Definition: parsenodes.h:193
List * distinctClause
Definition: parsenodes.h:199

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

3198 {
3199  switch (strength)
3200  {
3201  case LCS_NONE:
3202  Assert(false);
3203  break;
3204  case LCS_FORKEYSHARE:
3205  return "FOR KEY SHARE";
3206  case LCS_FORSHARE:
3207  return "FOR SHARE";
3208  case LCS_FORNOKEYUPDATE:
3209  return "FOR NO KEY UPDATE";
3210  case LCS_FORUPDATE:
3211  return "FOR UPDATE";
3212  }
3213  return "FOR some"; /* shouldn't happen */
3214 }
@ LCS_FORUPDATE
Definition: lockoptions.h:27
@ LCS_FORSHARE
Definition: lockoptions.h:25
@ LCS_FORKEYSHARE
Definition: lockoptions.h:24
@ LCS_FORNOKEYUPDATE
Definition: lockoptions.h:26

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

1946 {
1948  Oid sortop;
1949  Oid eqop;
1950  bool hashable;
1951 
1952  /* determine the eqop and optional sortop */
1953  get_sort_group_operators(rescoltype,
1954  false, true, false,
1955  &sortop, &eqop, NULL,
1956  &hashable);
1957 
1958  /*
1959  * The type cache doesn't believe that record is hashable (see
1960  * cache_record_field_properties()), but if the caller really needs hash
1961  * support, we can assume it does. Worst case, if any components of the
1962  * record don't support hashing, we will fail at execution.
1963  */
1964  if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
1965  hashable = true;
1966 
1967  /* we don't have a tlist yet, so can't assign sortgrouprefs */
1968  grpcl->tleSortGroupRef = 0;
1969  grpcl->eqop = eqop;
1970  grpcl->sortop = sortop;
1971  grpcl->nulls_first = false; /* OK with or without sortop */
1972  grpcl->hashable = hashable;
1973 
1974  return grpcl;
1975 }
void get_sort_group_operators(Oid argtype, bool needLT, bool needEQ, bool needGT, Oid *ltOpr, Oid *eqOpr, Oid *gtOpr, bool *isHashable)
Definition: parse_oper.c:180
unsigned int Oid
Definition: postgres_ext.h:31
Index tleSortGroupRef
Definition: parsenodes.h:1385

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.

110 {
111  ParseState *pstate = make_parsestate(NULL);
112  Query *query;
113  JumbleState *jstate = NULL;
114 
115  Assert(sourceText != NULL); /* required as of 8.4 */
116 
117  pstate->p_sourcetext = sourceText;
118 
119  if (numParams > 0)
120  setup_parse_fixed_parameters(pstate, paramTypes, numParams);
121 
122  pstate->p_queryEnv = queryEnv;
123 
124  query = transformTopLevelStmt(pstate, parseTree);
125 
126  if (IsQueryIdEnabled())
127  jstate = JumbleQuery(query);
128 
130  (*post_parse_analyze_hook) (pstate, query, jstate);
131 
132  free_parsestate(pstate);
133 
134  pgstat_report_query_id(query->queryId, false);
135 
136  return query;
137 }
void pgstat_report_query_id(uint64 query_id, bool force)
void free_parsestate(ParseState *pstate)
Definition: parse_node.c:77
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:44
void setup_parse_fixed_parameters(ParseState *pstate, const Oid *paramTypes, int numParams)
Definition: parse_param.c:67
Query * transformTopLevelStmt(ParseState *pstate, RawStmt *parseTree)
Definition: analyze.c:251
post_parse_analyze_hook_type post_parse_analyze_hook
Definition: analyze.c:60
static bool IsQueryIdEnabled(void)
Definition: queryjumble.h:77
JumbleState * JumbleQuery(Query *query)
QueryEnvironment * p_queryEnv
Definition: parse_node.h:219
const char * p_sourcetext
Definition: parse_node.h:192

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.

150 {
151  ParseState *pstate = make_parsestate(NULL);
152  Query *query;
153  JumbleState *jstate = NULL;
154 
155  Assert(sourceText != NULL); /* required as of 8.4 */
156 
157  pstate->p_sourcetext = sourceText;
158 
159  setup_parse_variable_parameters(pstate, paramTypes, numParams);
160 
161  pstate->p_queryEnv = queryEnv;
162 
163  query = transformTopLevelStmt(pstate, parseTree);
164 
165  /* make sure all is well with parameter types */
166  check_variable_parameters(pstate, query);
167 
168  if (IsQueryIdEnabled())
169  jstate = JumbleQuery(query);
170 
172  (*post_parse_analyze_hook) (pstate, query, jstate);
173 
174  free_parsestate(pstate);
175 
176  pgstat_report_query_id(query->queryId, false);
177 
178  return query;
179 }
void check_variable_parameters(ParseState *pstate, Query *query)
Definition: parse_param.c:268
void setup_parse_variable_parameters(ParseState *pstate, Oid **paramTypes, int *numParams)
Definition: parse_param.c:83

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.

192 {
193  ParseState *pstate = make_parsestate(NULL);
194  Query *query;
195  JumbleState *jstate = NULL;
196 
197  Assert(sourceText != NULL); /* required as of 8.4 */
198 
199  pstate->p_sourcetext = sourceText;
200  pstate->p_queryEnv = queryEnv;
201  (*parserSetup) (pstate, parserSetupArg);
202 
203  query = transformTopLevelStmt(pstate, parseTree);
204 
205  if (IsQueryIdEnabled())
206  jstate = JumbleQuery(query);
207 
209  (*post_parse_analyze_hook) (pstate, query, jstate);
210 
211  free_parsestate(pstate);
212 
213  pgstat_report_query_id(query->queryId, false);
214 
215  return query;
216 }

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.

228 {
229  ParseState *pstate = make_parsestate(parentParseState);
230  Query *query;
231 
232  pstate->p_parent_cte = parentCTE;
233  pstate->p_locked_from_parent = locked_from_parent;
234  pstate->p_resolve_unknowns = resolve_unknowns;
235 
236  query = transformStmt(pstate, parseTree);
237 
238  free_parsestate(pstate);
239 
240  return query;
241 }
Query * transformStmt(ParseState *pstate, Node *parseTree)
Definition: analyze.c:314
bool p_locked_from_parent
Definition: parse_node.h:214
bool p_resolve_unknowns
Definition: parse_node.h:216
CommonTableExpr * p_parent_cte
Definition: parse_node.h:205

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

445 {
446  bool result;
447 
448  switch (nodeTag(parseTree->stmt))
449  {
450  /*
451  * Optimizable statements
452  */
453  case T_InsertStmt:
454  case T_DeleteStmt:
455  case T_UpdateStmt:
456  case T_MergeStmt:
457  case T_SelectStmt:
458  case T_ReturnStmt:
459  case T_PLAssignStmt:
460  result = true;
461  break;
462 
463  /*
464  * Special cases
465  */
466  case T_DeclareCursorStmt:
467  case T_ExplainStmt:
468  case T_CreateTableAsStmt:
469  case T_CallStmt:
470  result = true;
471  break;
472 
473  default:
474  /* all other statements just get wrapped in a CMD_UTILITY Query */
475  result = false;
476  break;
477  }
478 
479  return result;
480 }
#define nodeTag(nodeptr)
Definition: nodes.h:133
Node * stmt
Definition: parsenodes.h:1861

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

1012 {
1013  List *result;
1014  ListCell *lc;
1015  ListCell *icols;
1016  ListCell *attnos;
1017 
1018  /*
1019  * Check length of expr list. It must not have more expressions than
1020  * there are target columns. We allow fewer, but only if no explicit
1021  * columns list was given (the remaining columns are implicitly
1022  * defaulted). Note we must check this *after* transformation because
1023  * that could expand '*' into multiple items.
1024  */
1025  if (list_length(exprlist) > list_length(icolumns))
1026  ereport(ERROR,
1027  (errcode(ERRCODE_SYNTAX_ERROR),
1028  errmsg("INSERT has more expressions than target columns"),
1029  parser_errposition(pstate,
1030  exprLocation(list_nth(exprlist,
1031  list_length(icolumns))))));
1032  if (stmtcols != NIL &&
1033  list_length(exprlist) < list_length(icolumns))
1034  {
1035  /*
1036  * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
1037  * where the user accidentally created a RowExpr instead of separate
1038  * columns. Add a suitable hint if that seems to be the problem,
1039  * because the main error message is quite misleading for this case.
1040  * (If there's no stmtcols, you'll get something about data type
1041  * mismatch, which is less misleading so we don't worry about giving a
1042  * hint in that case.)
1043  */
1044  ereport(ERROR,
1045  (errcode(ERRCODE_SYNTAX_ERROR),
1046  errmsg("INSERT has more target columns than expressions"),
1047  ((list_length(exprlist) == 1 &&
1048  count_rowexpr_columns(pstate, linitial(exprlist)) ==
1049  list_length(icolumns)) ?
1050  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),
1051  parser_errposition(pstate,
1052  exprLocation(list_nth(icolumns,
1053  list_length(exprlist))))));
1054  }
1055 
1056  /*
1057  * Prepare columns for assignment to target table.
1058  */
1059  result = NIL;
1060  forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
1061  {
1062  Expr *expr = (Expr *) lfirst(lc);
1063  ResTarget *col = lfirst_node(ResTarget, icols);
1064  int attno = lfirst_int(attnos);
1065 
1066  expr = transformAssignedExpr(pstate, expr,
1068  col->name,
1069  attno,
1070  col->indirection,
1071  col->location);
1072 
1073  if (strip_indirection)
1074  {
1075  while (expr)
1076  {
1077  if (IsA(expr, FieldStore))
1078  {
1079  FieldStore *fstore = (FieldStore *) expr;
1080 
1081  expr = (Expr *) linitial(fstore->newvals);
1082  }
1083  else if (IsA(expr, SubscriptingRef))
1084  {
1085  SubscriptingRef *sbsref = (SubscriptingRef *) expr;
1086 
1087  if (sbsref->refassgnexpr == NULL)
1088  break;
1089 
1090  expr = sbsref->refassgnexpr;
1091  }
1092  else
1093  break;
1094  }
1095  }
1096 
1097  result = lappend(result, expr);
1098  }
1099 
1100  return result;
1101 }
int errhint(const char *fmt,...)
Definition: elog.c:1316
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1312
#define IsA(nodeptr, _type_)
Definition: nodes.h:179
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
@ EXPR_KIND_INSERT_TARGET
Definition: parse_node.h:55
Expr * transformAssignedExpr(ParseState *pstate, Expr *expr, ParseExprKind exprKind, const char *colname, int attrno, List *indirection, int location)
Definition: parse_target.c:453
static int count_rowexpr_columns(ParseState *pstate, Node *expr)
Definition: analyze.c:1285
#define lfirst(lc)
Definition: pg_list.h:172
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152
#define lfirst_int(lc)
Definition: pg_list.h:173
#define forthree(cell1, list1, cell2, list2, cell3, list3)
Definition: pg_list.h:512
#define linitial(l)
Definition: pg_list.h:178
static void * list_nth(const List *list, int n)
Definition: pg_list.h:299
List * newvals
Definition: primnodes.h:1095
int location
Definition: parsenodes.h:510
List * indirection
Definition: parsenodes.h:508
char * name
Definition: parsenodes.h:507
Expr * refassgnexpr
Definition: primnodes.h:638

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.

315 {
316  Query *result;
317 
318  /*
319  * We apply RAW_EXPRESSION_COVERAGE_TEST testing to basic DML statements;
320  * we can't just run it on everything because raw_expression_tree_walker()
321  * doesn't claim to handle utility statements.
322  */
323 #ifdef RAW_EXPRESSION_COVERAGE_TEST
324  switch (nodeTag(parseTree))
325  {
326  case T_SelectStmt:
327  case T_InsertStmt:
328  case T_UpdateStmt:
329  case T_DeleteStmt:
330  case T_MergeStmt:
331  (void) test_raw_expression_coverage(parseTree, NULL);
332  break;
333  default:
334  break;
335  }
336 #endif /* RAW_EXPRESSION_COVERAGE_TEST */
337 
338  /*
339  * Caution: when changing the set of statement types that have non-default
340  * processing here, see also stmt_requires_parse_analysis() and
341  * analyze_requires_snapshot().
342  */
343  switch (nodeTag(parseTree))
344  {
345  /*
346  * Optimizable statements
347  */
348  case T_InsertStmt:
349  result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
350  break;
351 
352  case T_DeleteStmt:
353  result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree);
354  break;
355 
356  case T_UpdateStmt:
357  result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree);
358  break;
359 
360  case T_MergeStmt:
361  result = transformMergeStmt(pstate, (MergeStmt *) parseTree);
362  break;
363 
364  case T_SelectStmt:
365  {
366  SelectStmt *n = (SelectStmt *) parseTree;
367 
368  if (n->valuesLists)
369  result = transformValuesClause(pstate, n);
370  else if (n->op == SETOP_NONE)
371  result = transformSelectStmt(pstate, n);
372  else
373  result = transformSetOperationStmt(pstate, n);
374  }
375  break;
376 
377  case T_ReturnStmt:
378  result = transformReturnStmt(pstate, (ReturnStmt *) parseTree);
379  break;
380 
381  case T_PLAssignStmt:
382  result = transformPLAssignStmt(pstate,
383  (PLAssignStmt *) parseTree);
384  break;
385 
386  /*
387  * Special cases
388  */
389  case T_DeclareCursorStmt:
390  result = transformDeclareCursorStmt(pstate,
391  (DeclareCursorStmt *) parseTree);
392  break;
393 
394  case T_ExplainStmt:
395  result = transformExplainStmt(pstate,
396  (ExplainStmt *) parseTree);
397  break;
398 
399  case T_CreateTableAsStmt:
400  result = transformCreateTableAsStmt(pstate,
401  (CreateTableAsStmt *) parseTree);
402  break;
403 
404  case T_CallStmt:
405  result = transformCallStmt(pstate,
406  (CallStmt *) parseTree);
407  break;
408 
409  default:
410 
411  /*
412  * other statements don't require any transformation; just return
413  * the original parsetree with a Query node plastered on top.
414  */
415  result = makeNode(Query);
416  result->commandType = CMD_UTILITY;
417  result->utilityStmt = (Node *) parseTree;
418  break;
419  }
420 
421  /* Mark as original query until we learn differently */
422  result->querySource = QSRC_ORIGINAL;
423  result->canSetTag = true;
424 
425  return result;
426 }
@ CMD_UTILITY
Definition: nodes.h:281
Query * transformMergeStmt(ParseState *pstate, MergeStmt *stmt)
Definition: parse_merge.c:96
@ SETOP_NONE
Definition: parsenodes.h:1948
@ QSRC_ORIGINAL
Definition: parsenodes.h:36
static Query * transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
Definition: analyze.c:511
static Query * transformReturnStmt(ParseState *pstate, ReturnStmt *stmt)
Definition: analyze.c:2377
static Query * transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt)
Definition: analyze.c:2603
static Query * transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt)
Definition: analyze.c:2997
static Query * transformCallStmt(ParseState *pstate, CallStmt *stmt)
Definition: analyze.c:3072
static Query * transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1689
static Query * transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
Definition: analyze.c:2408
static Query * transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1327
static Query * transformExplainStmt(ParseState *pstate, ExplainStmt *stmt)
Definition: analyze.c:2945
static Query * transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
Definition: analyze.c:2852
static Query * transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
Definition: analyze.c:582
static Query * transformValuesClause(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1470
Definition: nodes.h:129
CmdType commandType
Definition: parsenodes.h:120
Node * utilityStmt
Definition: parsenodes.h:135
List * valuesLists
Definition: parsenodes.h:1980
SetOperation op
Definition: parsenodes.h:1996

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.

252 {
253  Query *result;
254 
255  /* We're at top level, so allow SELECT INTO */
256  result = transformOptionalSelectInto(pstate, parseTree->stmt);
257 
258  result->stmt_location = parseTree->stmt_location;
259  result->stmt_len = parseTree->stmt_len;
260 
261  return result;
262 }
static Query * transformOptionalSelectInto(ParseState *pstate, Node *parseTree)
Definition: analyze.c:275
int stmt_location
Definition: parsenodes.h:228
int stmt_len
Definition: parsenodes.h:1863
int stmt_location
Definition: parsenodes.h:1862

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

2474 {
2475  List *tlist = NIL;
2476  RTEPermissionInfo *target_perminfo;
2477  ListCell *orig_tl;
2478  ListCell *tl;
2479 
2480  tlist = transformTargetList(pstate, origTlist,
2482 
2483  /* Prepare to assign non-conflicting resnos to resjunk attributes */
2486 
2487  /* Prepare non-junk columns for assignment to target table */
2488  target_perminfo = pstate->p_target_nsitem->p_perminfo;
2489  orig_tl = list_head(origTlist);
2490 
2491  foreach(tl, tlist)
2492  {
2493  TargetEntry *tle = (TargetEntry *) lfirst(tl);
2494  ResTarget *origTarget;
2495  int attrno;
2496 
2497  if (tle->resjunk)
2498  {
2499  /*
2500  * Resjunk nodes need no additional processing, but be sure they
2501  * have resnos that do not match any target columns; else rewriter
2502  * or planner might get confused. They don't need a resname
2503  * either.
2504  */
2505  tle->resno = (AttrNumber) pstate->p_next_resno++;
2506  tle->resname = NULL;
2507  continue;
2508  }
2509  if (orig_tl == NULL)
2510  elog(ERROR, "UPDATE target count mismatch --- internal error");
2511  origTarget = lfirst_node(ResTarget, orig_tl);
2512 
2513  attrno = attnameAttNum(pstate->p_target_relation,
2514  origTarget->name, true);
2515  if (attrno == InvalidAttrNumber)
2516  ereport(ERROR,
2517  (errcode(ERRCODE_UNDEFINED_COLUMN),
2518  errmsg("column \"%s\" of relation \"%s\" does not exist",
2519  origTarget->name,
2521  parser_errposition(pstate, origTarget->location)));
2522 
2523  updateTargetListEntry(pstate, tle, origTarget->name,
2524  attrno,
2525  origTarget->indirection,
2526  origTarget->location);
2527 
2528  /* Mark the target column as requiring update permissions */
2529  target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
2531 
2532  orig_tl = lnext(origTlist, orig_tl);
2533  }
2534  if (orig_tl != NULL)
2535  elog(ERROR, "UPDATE target count mismatch --- internal error");
2536 
2537  return tlist;
2538 }
int16 AttrNumber
Definition: attnum.h:21
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:753
@ EXPR_KIND_UPDATE_SOURCE
Definition: parse_node.h:56
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
List * transformTargetList(ParseState *pstate, List *targetlist, ParseExprKind exprKind)
Definition: parse_target.c:122
void updateTargetListEntry(ParseState *pstate, TargetEntry *tle, char *colname, int attrno, List *indirection, int location)
Definition: parse_target.c:620
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
#define RelationGetRelationName(relation)
Definition: rel.h:538
RTEPermissionInfo * p_perminfo
Definition: parse_node.h:288
ParseNamespaceItem * p_target_nsitem
Definition: parse_node.h:207
int p_next_resno
Definition: parse_node.h:211
Relation p_target_relation
Definition: parse_node.h:206
Bitmapset * updatedCols
Definition: parsenodes.h:1242
AttrNumber resno
Definition: primnodes.h:1924
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27

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