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

432 {
433  bool result;
434 
435  switch (nodeTag(parseTree->stmt))
436  {
437  /*
438  * Optimizable statements
439  */
440  case T_InsertStmt:
441  case T_DeleteStmt:
442  case T_UpdateStmt:
443  case T_MergeStmt:
444  case T_SelectStmt:
445  case T_PLAssignStmt:
446  result = true;
447  break;
448 
449  /*
450  * Special cases
451  */
452  case T_DeclareCursorStmt:
453  case T_ExplainStmt:
454  case T_CreateTableAsStmt:
455  /* yes, because we must analyze the contained statement */
456  result = true;
457  break;
458 
459  default:
460  /* other utility statements don't have any real parse analysis */
461  result = false;
462  break;
463  }
464 
465  return result;
466 }
#define nodeTag(nodeptr)
Definition: nodes.h:133
Node * stmt
Definition: parsenodes.h:1847

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.

3478 {
3479  RowMarkClause *rc;
3480 
3481  Assert(strength != LCS_NONE); /* else caller error */
3482 
3483  /* If it's an explicit clause, make sure hasForUpdate gets set */
3484  if (!pushedDown)
3485  qry->hasForUpdate = true;
3486 
3487  /* Check for pre-existing entry for same rtindex */
3488  if ((rc = get_parse_rowmark(qry, rtindex)) != NULL)
3489  {
3490  /*
3491  * If the same RTE is specified with more than one locking strength,
3492  * use the strongest. (Reasonable, since you can't take both a shared
3493  * and exclusive lock at the same time; it'll end up being exclusive
3494  * anyway.)
3495  *
3496  * Similarly, if the same RTE is specified with more than one lock
3497  * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
3498  * turn wins over waiting for the lock (the default). This is a bit
3499  * more debatable but raising an error doesn't seem helpful. (Consider
3500  * for instance SELECT FOR UPDATE NOWAIT from a view that internally
3501  * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP
3502  * LOCKED is reasonable since the former throws an error in case of
3503  * coming across a locked tuple, which may be undesirable in some
3504  * cases but it seems better than silently returning inconsistent
3505  * results.
3506  *
3507  * And of course pushedDown becomes false if any clause is explicit.
3508  */
3509  rc->strength = Max(rc->strength, strength);
3510  rc->waitPolicy = Max(rc->waitPolicy, waitPolicy);
3511  rc->pushedDown &= pushedDown;
3512  return;
3513  }
3514 
3515  /* Make a new RowMarkClause */
3516  rc = makeNode(RowMarkClause);
3517  rc->rti = rtindex;
3518  rc->strength = strength;
3519  rc->waitPolicy = waitPolicy;
3520  rc->pushedDown = pushedDown;
3521  qry->rowMarks = lappend(qry->rowMarks, rc);
3522 }
#define Max(x, y)
Definition: c.h:982
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:215
LockClauseStrength strength
Definition: parsenodes.h:1534
LockWaitPolicy waitPolicy
Definition: parsenodes.h:1535

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.

1179 {
1180  List *result = NIL;
1181  int attno;
1182  Var *var;
1183  TargetEntry *te;
1184 
1185  /*
1186  * Note that resnos of the tlist must correspond to attnos of the
1187  * underlying relation, hence we need entries for dropped columns too.
1188  */
1189  for (attno = 0; attno < RelationGetNumberOfAttributes(targetrel); attno++)
1190  {
1191  Form_pg_attribute attr = TupleDescAttr(targetrel->rd_att, attno);
1192  char *name;
1193 
1194  if (attr->attisdropped)
1195  {
1196  /*
1197  * can't use atttypid here, but it doesn't really matter what type
1198  * the Const claims to be.
1199  */
1200  var = (Var *) makeNullConst(INT4OID, -1, InvalidOid);
1201  name = NULL;
1202  }
1203  else
1204  {
1205  var = makeVar(exclRelIndex, attno + 1,
1206  attr->atttypid, attr->atttypmod,
1207  attr->attcollation,
1208  0);
1209  name = pstrdup(NameStr(attr->attname));
1210  }
1211 
1212  te = makeTargetEntry((Expr *) var,
1213  attno + 1,
1214  name,
1215  false);
1216 
1217  result = lappend(result, te);
1218  }
1219 
1220  /*
1221  * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like
1222  * the other entries in the EXCLUDED tlist, its resno must match the Var's
1223  * varattno, else the wrong things happen while resolving references in
1224  * setrefs.c. This is against normal conventions for targetlists, but
1225  * it's okay since we don't use this as a real tlist.
1226  */
1227  var = makeVar(exclRelIndex, InvalidAttrNumber,
1228  targetrel->rd_rel->reltype,
1229  -1, InvalidOid, 0);
1230  te = makeTargetEntry((Expr *) var, InvalidAttrNumber, NULL, true);
1231  result = lappend(result, te);
1232 
1233  return result;
1234 }
#define InvalidAttrNumber
Definition: attnum.h:23
#define NameStr(name)
Definition: c.h:730
const char * name
Definition: encode.c:571
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:226
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92

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.

3185 {
3186  Assert(strength != LCS_NONE); /* else caller error */
3187 
3188  if (qry->setOperations)
3189  ereport(ERROR,
3190  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3191  /*------
3192  translator: %s is a SQL row locking clause such as FOR UPDATE */
3193  errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
3194  LCS_asString(strength))));
3195  if (qry->distinctClause != NIL)
3196  ereport(ERROR,
3197  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3198  /*------
3199  translator: %s is a SQL row locking clause such as FOR UPDATE */
3200  errmsg("%s is not allowed with DISTINCT clause",
3201  LCS_asString(strength))));
3202  if (qry->groupClause != NIL || qry->groupingSets != NIL)
3203  ereport(ERROR,
3204  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3205  /*------
3206  translator: %s is a SQL row locking clause such as FOR UPDATE */
3207  errmsg("%s is not allowed with GROUP BY clause",
3208  LCS_asString(strength))));
3209  if (qry->havingQual != NULL)
3210  ereport(ERROR,
3211  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3212  /*------
3213  translator: %s is a SQL row locking clause such as FOR UPDATE */
3214  errmsg("%s is not allowed with HAVING clause",
3215  LCS_asString(strength))));
3216  if (qry->hasAggs)
3217  ereport(ERROR,
3218  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3219  /*------
3220  translator: %s is a SQL row locking clause such as FOR UPDATE */
3221  errmsg("%s is not allowed with aggregate functions",
3222  LCS_asString(strength))));
3223  if (qry->hasWindowFuncs)
3224  ereport(ERROR,
3225  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3226  /*------
3227  translator: %s is a SQL row locking clause such as FOR UPDATE */
3228  errmsg("%s is not allowed with window functions",
3229  LCS_asString(strength))));
3230  if (qry->hasTargetSRFs)
3231  ereport(ERROR,
3232  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3233  /*------
3234  translator: %s is a SQL row locking clause such as FOR UPDATE */
3235  errmsg("%s is not allowed with set-returning functions in the target list",
3236  LCS_asString(strength))));
3237 }
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:3159
Node * setOperations
Definition: parsenodes.h:217
List * groupClause
Definition: parsenodes.h:198
Node * havingQual
Definition: parsenodes.h:203
List * groupingSets
Definition: parsenodes.h:201
List * distinctClause
Definition: parsenodes.h:207

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.

3160 {
3161  switch (strength)
3162  {
3163  case LCS_NONE:
3164  Assert(false);
3165  break;
3166  case LCS_FORKEYSHARE:
3167  return "FOR KEY SHARE";
3168  case LCS_FORSHARE:
3169  return "FOR SHARE";
3170  case LCS_FORNOKEYUPDATE:
3171  return "FOR NO KEY UPDATE";
3172  case LCS_FORUPDATE:
3173  return "FOR UPDATE";
3174  }
3175  return "FOR some"; /* shouldn't happen */
3176 }
@ 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 1907 of file analyze.c.

1908 {
1910  Oid sortop;
1911  Oid eqop;
1912  bool hashable;
1913 
1914  /* determine the eqop and optional sortop */
1915  get_sort_group_operators(rescoltype,
1916  false, true, false,
1917  &sortop, &eqop, NULL,
1918  &hashable);
1919 
1920  /*
1921  * The type cache doesn't believe that record is hashable (see
1922  * cache_record_field_properties()), but if the caller really needs hash
1923  * support, we can assume it does. Worst case, if any components of the
1924  * record don't support hashing, we will fail at execution.
1925  */
1926  if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
1927  hashable = true;
1928 
1929  /* we don't have a tlist yet, so can't assign sortgrouprefs */
1930  grpcl->tleSortGroupRef = 0;
1931  grpcl->eqop = eqop;
1932  grpcl->sortop = sortop;
1933  grpcl->nulls_first = false; /* OK with or without sortop */
1934  grpcl->hashable = hashable;
1935 
1936  return grpcl;
1937 }
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:192
unsigned int Oid
Definition: postgres_ext.h:31
Index tleSortGroupRef
Definition: parsenodes.h:1393

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, sourceText);
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, const char *querytext)
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, sourceText);
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, sourceText);
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().

◆ transformInsertRow()

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

Definition at line 971 of file analyze.c.

974 {
975  List *result;
976  ListCell *lc;
977  ListCell *icols;
978  ListCell *attnos;
979 
980  /*
981  * Check length of expr list. It must not have more expressions than
982  * there are target columns. We allow fewer, but only if no explicit
983  * columns list was given (the remaining columns are implicitly
984  * defaulted). Note we must check this *after* transformation because
985  * that could expand '*' into multiple items.
986  */
987  if (list_length(exprlist) > list_length(icolumns))
988  ereport(ERROR,
989  (errcode(ERRCODE_SYNTAX_ERROR),
990  errmsg("INSERT has more expressions than target columns"),
991  parser_errposition(pstate,
992  exprLocation(list_nth(exprlist,
993  list_length(icolumns))))));
994  if (stmtcols != NIL &&
995  list_length(exprlist) < list_length(icolumns))
996  {
997  /*
998  * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
999  * where the user accidentally created a RowExpr instead of separate
1000  * columns. Add a suitable hint if that seems to be the problem,
1001  * because the main error message is quite misleading for this case.
1002  * (If there's no stmtcols, you'll get something about data type
1003  * mismatch, which is less misleading so we don't worry about giving a
1004  * hint in that case.)
1005  */
1006  ereport(ERROR,
1007  (errcode(ERRCODE_SYNTAX_ERROR),
1008  errmsg("INSERT has more target columns than expressions"),
1009  ((list_length(exprlist) == 1 &&
1010  count_rowexpr_columns(pstate, linitial(exprlist)) ==
1011  list_length(icolumns)) ?
1012  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),
1013  parser_errposition(pstate,
1014  exprLocation(list_nth(icolumns,
1015  list_length(exprlist))))));
1016  }
1017 
1018  /*
1019  * Prepare columns for assignment to target table.
1020  */
1021  result = NIL;
1022  forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
1023  {
1024  Expr *expr = (Expr *) lfirst(lc);
1025  ResTarget *col = lfirst_node(ResTarget, icols);
1026  int attno = lfirst_int(attnos);
1027 
1028  expr = transformAssignedExpr(pstate, expr,
1030  col->name,
1031  attno,
1032  col->indirection,
1033  col->location);
1034 
1035  if (strip_indirection)
1036  {
1037  while (expr)
1038  {
1039  if (IsA(expr, FieldStore))
1040  {
1041  FieldStore *fstore = (FieldStore *) expr;
1042 
1043  expr = (Expr *) linitial(fstore->newvals);
1044  }
1045  else if (IsA(expr, SubscriptingRef))
1046  {
1047  SubscriptingRef *sbsref = (SubscriptingRef *) expr;
1048 
1049  if (sbsref->refassgnexpr == NULL)
1050  break;
1051 
1052  expr = sbsref->refassgnexpr;
1053  }
1054  else
1055  break;
1056  }
1057  }
1058 
1059  result = lappend(result, expr);
1060  }
1061 
1062  return result;
1063 }
int errhint(const char *fmt,...)
Definition: elog.c:1316
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1314
#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:1247
#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:1087
int location
Definition: parsenodes.h:518
List * indirection
Definition: parsenodes.h:516
char * name
Definition: parsenodes.h:515
Expr * refassgnexpr
Definition: primnodes.h:630

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  switch (nodeTag(parseTree))
339  {
340  /*
341  * Optimizable statements
342  */
343  case T_InsertStmt:
344  result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
345  break;
346 
347  case T_DeleteStmt:
348  result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree);
349  break;
350 
351  case T_UpdateStmt:
352  result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree);
353  break;
354 
355  case T_MergeStmt:
356  result = transformMergeStmt(pstate, (MergeStmt *) parseTree);
357  break;
358 
359  case T_SelectStmt:
360  {
361  SelectStmt *n = (SelectStmt *) parseTree;
362 
363  if (n->valuesLists)
364  result = transformValuesClause(pstate, n);
365  else if (n->op == SETOP_NONE)
366  result = transformSelectStmt(pstate, n);
367  else
368  result = transformSetOperationStmt(pstate, n);
369  }
370  break;
371 
372  case T_ReturnStmt:
373  result = transformReturnStmt(pstate, (ReturnStmt *) parseTree);
374  break;
375 
376  case T_PLAssignStmt:
377  result = transformPLAssignStmt(pstate,
378  (PLAssignStmt *) parseTree);
379  break;
380 
381  /*
382  * Special cases
383  */
384  case T_DeclareCursorStmt:
385  result = transformDeclareCursorStmt(pstate,
386  (DeclareCursorStmt *) parseTree);
387  break;
388 
389  case T_ExplainStmt:
390  result = transformExplainStmt(pstate,
391  (ExplainStmt *) parseTree);
392  break;
393 
394  case T_CreateTableAsStmt:
395  result = transformCreateTableAsStmt(pstate,
396  (CreateTableAsStmt *) parseTree);
397  break;
398 
399  case T_CallStmt:
400  result = transformCallStmt(pstate,
401  (CallStmt *) parseTree);
402  break;
403 
404  default:
405 
406  /*
407  * other statements don't require any transformation; just return
408  * the original parsetree with a Query node plastered on top.
409  */
410  result = makeNode(Query);
411  result->commandType = CMD_UTILITY;
412  result->utilityStmt = (Node *) parseTree;
413  break;
414  }
415 
416  /* Mark as original query until we learn differently */
417  result->querySource = QSRC_ORIGINAL;
418  result->canSetTag = true;
419 
420  return result;
421 }
@ CMD_UTILITY
Definition: nodes.h:281
Query * transformMergeStmt(ParseState *pstate, MergeStmt *stmt)
Definition: parse_merge.c:96
@ SETOP_NONE
Definition: parsenodes.h:1934
@ QSRC_ORIGINAL
Definition: parsenodes.h:43
static Query * transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
Definition: analyze.c:473
static Query * transformReturnStmt(ParseState *pstate, ReturnStmt *stmt)
Definition: analyze.c:2339
static Query * transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt)
Definition: analyze.c:2565
static Query * transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt)
Definition: analyze.c:2959
static Query * transformCallStmt(ParseState *pstate, CallStmt *stmt)
Definition: analyze.c:3034
static Query * transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1651
static Query * transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
Definition: analyze.c:2370
static Query * transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1289
static Query * transformExplainStmt(ParseState *pstate, ExplainStmt *stmt)
Definition: analyze.c:2907
static Query * transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
Definition: analyze.c:2814
static Query * transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
Definition: analyze.c:544
static Query * transformValuesClause(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1432
Definition: nodes.h:129
CmdType commandType
Definition: parsenodes.h:128
Node * utilityStmt
Definition: parsenodes.h:143
List * valuesLists
Definition: parsenodes.h:1966
SetOperation op
Definition: parsenodes.h:1982

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:236
int stmt_len
Definition: parsenodes.h:1849
int stmt_location
Definition: parsenodes.h:1848

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.

2436 {
2437  List *tlist = NIL;
2438  RTEPermissionInfo *target_perminfo;
2439  ListCell *orig_tl;
2440  ListCell *tl;
2441 
2442  tlist = transformTargetList(pstate, origTlist,
2444 
2445  /* Prepare to assign non-conflicting resnos to resjunk attributes */
2448 
2449  /* Prepare non-junk columns for assignment to target table */
2450  target_perminfo = pstate->p_target_nsitem->p_perminfo;
2451  orig_tl = list_head(origTlist);
2452 
2453  foreach(tl, tlist)
2454  {
2455  TargetEntry *tle = (TargetEntry *) lfirst(tl);
2456  ResTarget *origTarget;
2457  int attrno;
2458 
2459  if (tle->resjunk)
2460  {
2461  /*
2462  * Resjunk nodes need no additional processing, but be sure they
2463  * have resnos that do not match any target columns; else rewriter
2464  * or planner might get confused. They don't need a resname
2465  * either.
2466  */
2467  tle->resno = (AttrNumber) pstate->p_next_resno++;
2468  tle->resname = NULL;
2469  continue;
2470  }
2471  if (orig_tl == NULL)
2472  elog(ERROR, "UPDATE target count mismatch --- internal error");
2473  origTarget = lfirst_node(ResTarget, orig_tl);
2474 
2475  attrno = attnameAttNum(pstate->p_target_relation,
2476  origTarget->name, true);
2477  if (attrno == InvalidAttrNumber)
2478  ereport(ERROR,
2479  (errcode(ERRCODE_UNDEFINED_COLUMN),
2480  errmsg("column \"%s\" of relation \"%s\" does not exist",
2481  origTarget->name,
2483  parser_errposition(pstate, origTarget->location)));
2484 
2485  updateTargetListEntry(pstate, tle, origTarget->name,
2486  attrno,
2487  origTarget->indirection,
2488  origTarget->location);
2489 
2490  /* Mark the target column as requiring update permissions */
2491  target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
2493 
2494  orig_tl = lnext(origTlist, orig_tl);
2495  }
2496  if (orig_tl != NULL)
2497  elog(ERROR, "UPDATE target count mismatch --- internal error");
2498 
2499  return tlist;
2500 }
int16 AttrNumber
Definition: attnum.h:21
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:755
@ 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:1250
AttrNumber resno
Definition: primnodes.h:1888
#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