PostgreSQL Source Code  git master
parse_node.c File Reference
#include "postgres.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/pg_type.h"
#include "mb/pg_wchar.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "parser/parsetree.h"
#include "utils/builtins.h"
#include "utils/int8.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/varbit.h"
Include dependency graph for parse_node.c:

Go to the source code of this file.

Functions

static void pcb_error_callback (void *arg)
 
ParseStatemake_parsestate (ParseState *parentParseState)
 
void free_parsestate (ParseState *pstate)
 
int parser_errposition (ParseState *pstate, int location)
 
void setup_parser_errposition_callback (ParseCallbackState *pcbstate, ParseState *pstate, int location)
 
void cancel_parser_errposition_callback (ParseCallbackState *pcbstate)
 
Varmake_var (ParseState *pstate, RangeTblEntry *rte, int attrno, int location)
 
Oid transformContainerType (Oid *containerType, int32 *containerTypmod)
 
SubscriptingReftransformContainerSubscripts (ParseState *pstate, Node *containerBase, Oid containerType, Oid elementType, int32 containerTypMod, List *indirection, Node *assignFrom)
 
Constmake_const (ParseState *pstate, Value *value, int location)
 

Function Documentation

◆ cancel_parser_errposition_callback()

void cancel_parser_errposition_callback ( ParseCallbackState pcbstate)

◆ free_parsestate()

void free_parsestate ( ParseState pstate)

Definition at line 76 of file parse_node.c.

References ereport, errcode(), errmsg(), ERROR, MaxTupleAttributeNumber, NoLock, ParseState::p_next_resno, ParseState::p_target_relation, pfree(), and table_close().

Referenced by AlterPolicy(), CreatePolicy(), CreateTrigger(), inline_function(), parse_analyze(), parse_analyze_varparams(), parse_sub_analyze(), pg_analyze_and_rewrite_params(), RemoveRoleFromObjectPolicy(), standard_ProcessUtility(), transformIndexStmt(), transformInsertStmt(), and transformRuleStmt().

77 {
78  /*
79  * Check that we did not produce too many resnos; at the very least we
80  * cannot allow more than 2^16, since that would exceed the range of a
81  * AttrNumber. It seems safest to use MaxTupleAttributeNumber.
82  */
83  if (pstate->p_next_resno - 1 > MaxTupleAttributeNumber)
84  ereport(ERROR,
85  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
86  errmsg("target lists can have at most %d entries",
88 
89  if (pstate->p_target_relation != NULL)
91 
92  pfree(pstate);
93 }
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:133
#define MaxTupleAttributeNumber
Definition: htup_details.h:33
int errcode(int sqlerrcode)
Definition: elog.c:608
void pfree(void *pointer)
Definition: mcxt.c:1056
#define ERROR
Definition: elog.h:43
#define NoLock
Definition: lockdefs.h:34
int p_next_resno
Definition: parse_node.h:192
#define ereport(elevel, rest)
Definition: elog.h:141
int errmsg(const char *fmt,...)
Definition: elog.c:822
Relation p_target_relation
Definition: parse_node.h:187

◆ make_const()

Const* make_const ( ParseState pstate,
Value value,
int  location 
)

Definition at line 476 of file parse_node.c.

References bit_in(), cancel_parser_errposition_callback(), CStringGetDatum, DirectFunctionCall3, elog, ERROR, Int32GetDatum, Int64GetDatum(), intVal, InvalidOid, Const::location, makeConst(), nodeTag, numeric_in(), ObjectIdGetDatum, scanint8(), setup_parser_errposition_callback(), strVal, T_BitString, T_Float, T_Integer, T_Null, T_String, and val.

Referenced by transformExprRecurse().

477 {
478  Const *con;
479  Datum val;
480  int64 val64;
481  Oid typeid;
482  int typelen;
483  bool typebyval;
484  ParseCallbackState pcbstate;
485 
486  switch (nodeTag(value))
487  {
488  case T_Integer:
489  val = Int32GetDatum(intVal(value));
490 
491  typeid = INT4OID;
492  typelen = sizeof(int32);
493  typebyval = true;
494  break;
495 
496  case T_Float:
497  /* could be an oversize integer as well as a float ... */
498  if (scanint8(strVal(value), true, &val64))
499  {
500  /*
501  * It might actually fit in int32. Probably only INT_MIN can
502  * occur, but we'll code the test generally just to be sure.
503  */
504  int32 val32 = (int32) val64;
505 
506  if (val64 == (int64) val32)
507  {
508  val = Int32GetDatum(val32);
509 
510  typeid = INT4OID;
511  typelen = sizeof(int32);
512  typebyval = true;
513  }
514  else
515  {
516  val = Int64GetDatum(val64);
517 
518  typeid = INT8OID;
519  typelen = sizeof(int64);
520  typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */
521  }
522  }
523  else
524  {
525  /* arrange to report location if numeric_in() fails */
526  setup_parser_errposition_callback(&pcbstate, pstate, location);
528  CStringGetDatum(strVal(value)),
530  Int32GetDatum(-1));
532 
533  typeid = NUMERICOID;
534  typelen = -1; /* variable len */
535  typebyval = false;
536  }
537  break;
538 
539  case T_String:
540 
541  /*
542  * We assume here that UNKNOWN's internal representation is the
543  * same as CSTRING
544  */
545  val = CStringGetDatum(strVal(value));
546 
547  typeid = UNKNOWNOID; /* will be coerced later */
548  typelen = -2; /* cstring-style varwidth type */
549  typebyval = false;
550  break;
551 
552  case T_BitString:
553  /* arrange to report location if bit_in() fails */
554  setup_parser_errposition_callback(&pcbstate, pstate, location);
556  CStringGetDatum(strVal(value)),
558  Int32GetDatum(-1));
560  typeid = BITOID;
561  typelen = -1;
562  typebyval = false;
563  break;
564 
565  case T_Null:
566  /* return a null const */
567  con = makeConst(UNKNOWNOID,
568  -1,
569  InvalidOid,
570  -2,
571  (Datum) 0,
572  true,
573  false);
574  con->location = location;
575  return con;
576 
577  default:
578  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(value));
579  return NULL; /* keep compiler quiet */
580  }
581 
582  con = makeConst(typeid,
583  -1, /* typmod -1 is OK for all cases */
584  InvalidOid, /* all cases are uncollatable types */
585  typelen,
586  val,
587  false,
588  typebyval);
589  con->location = location;
590 
591  return con;
592 }
#define strVal(v)
Definition: value.h:54
unsigned int Oid
Definition: postgres_ext.h:31
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:297
signed int int32
Definition: c.h:347
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition: parse_node.c:160
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:43
Datum bit_in(PG_FUNCTION_ARGS)
Definition: varbit.c:146
#define CStringGetDatum(X)
Definition: postgres.h:578
Datum numeric_in(PG_FUNCTION_ARGS)
Definition: numeric.c:573
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1699
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition: parse_node.c:144
#define DirectFunctionCall3(func, arg1, arg2, arg3)
Definition: fmgr.h:621
int location
Definition: primnodes.h:207
uintptr_t Datum
Definition: postgres.h:367
#define InvalidOid
Definition: postgres_ext.h:36
#define nodeTag(nodeptr)
Definition: nodes.h:530
Definition: nodes.h:292
Definition: nodes.h:289
#define Int32GetDatum(X)
Definition: postgres.h:479
#define intVal(v)
Definition: value.h:52
#define elog(elevel,...)
Definition: elog.h:228
long val
Definition: informix.c:684
bool scanint8(const char *str, bool errorOK, int64 *result)
Definition: int8.c:56

◆ make_parsestate()

ParseState* make_parsestate ( ParseState parentParseState)

Definition at line 43 of file parse_node.c.

References ParseState::p_coerce_param_hook, ParseState::p_next_resno, ParseState::p_paramref_hook, ParseState::p_post_columnref_hook, ParseState::p_pre_columnref_hook, ParseState::p_queryEnv, ParseState::p_ref_hook_state, ParseState::p_resolve_unknowns, ParseState::p_sourcetext, palloc0(), and ParseState::parentParseState.

Referenced by AddRelationNewConstraints(), AlterDomainDefault(), AlterPolicy(), ATPrepAlterColumnType(), check_new_partition_bound(), convert_ANY_sublink_to_join(), copy_table(), CreatePolicy(), CreateTrigger(), DefineDomain(), DefineRelation(), domainAddConstraint(), EvaluateParams(), inline_function(), parse_analyze(), parse_analyze_varparams(), parse_sub_analyze(), pg_analyze_and_rewrite_params(), PrepareQuery(), RemoveRoleFromObjectPolicy(), rewriteTargetView(), standard_ProcessUtility(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformAlterTableStmt(), transformCreateStmt(), transformIndexStmt(), transformInsertStmt(), transformPartitionSpec(), transformRuleStmt(), and UpdateRangeTableOfViewParse().

44 {
45  ParseState *pstate;
46 
47  pstate = palloc0(sizeof(ParseState));
48 
49  pstate->parentParseState = parentParseState;
50 
51  /* Fill in fields that don't start at null/false/zero */
52  pstate->p_next_resno = 1;
53  pstate->p_resolve_unknowns = true;
54 
55  if (parentParseState)
56  {
57  pstate->p_sourcetext = parentParseState->p_sourcetext;
58  /* all hooks are copied from parent */
59  pstate->p_pre_columnref_hook = parentParseState->p_pre_columnref_hook;
60  pstate->p_post_columnref_hook = parentParseState->p_post_columnref_hook;
61  pstate->p_paramref_hook = parentParseState->p_paramref_hook;
62  pstate->p_coerce_param_hook = parentParseState->p_coerce_param_hook;
63  pstate->p_ref_hook_state = parentParseState->p_ref_hook_state;
64  /* query environment stays in context for the whole parse analysis */
65  pstate->p_queryEnv = parentParseState->p_queryEnv;
66  }
67 
68  return pstate;
69 }
QueryEnvironment * p_queryEnv
Definition: parse_node.h:200
CoerceParamHook p_coerce_param_hook
Definition: parse_node.h:218
PostParseColumnRefHook p_post_columnref_hook
Definition: parse_node.h:216
bool p_resolve_unknowns
Definition: parse_node.h:197
ParseParamRefHook p_paramref_hook
Definition: parse_node.h:217
int p_next_resno
Definition: parse_node.h:192
const char * p_sourcetext
Definition: parse_node.h:176
struct ParseState * parentParseState
Definition: parse_node.h:175
void * palloc0(Size size)
Definition: mcxt.c:980
void * p_ref_hook_state
Definition: parse_node.h:219
PreParseColumnRefHook p_pre_columnref_hook
Definition: parse_node.h:215

◆ make_var()

Var* make_var ( ParseState pstate,
RangeTblEntry rte,
int  attrno,
int  location 
)

Definition at line 188 of file parse_node.c.

References get_rte_attribute_type(), Var::location, makeVar(), and RTERangeTablePosn().

Referenced by scanRTEForColumn(), and transformAssignedExpr().

189 {
190  Var *result;
191  int vnum,
192  sublevels_up;
193  Oid vartypeid;
194  int32 type_mod;
195  Oid varcollid;
196 
197  vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
198  get_rte_attribute_type(rte, attrno, &vartypeid, &type_mod, &varcollid);
199  result = makeVar(vnum, attrno, vartypeid, type_mod, varcollid, sublevels_up);
200  result->location = location;
201  return result;
202 }
void get_rte_attribute_type(RangeTblEntry *rte, AttrNumber attnum, Oid *vartype, int32 *vartypmod, Oid *varcollid)
unsigned int Oid
Definition: postgres_ext.h:31
Definition: primnodes.h:167
signed int int32
Definition: c.h:347
int location
Definition: primnodes.h:182
Var * makeVar(Index varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition: makefuncs.c:66
int RTERangeTablePosn(ParseState *pstate, RangeTblEntry *rte, int *sublevels_up)

◆ parser_errposition()

int parser_errposition ( ParseState pstate,
int  location 
)

Definition at line 110 of file parse_node.c.

References errposition(), ParseState::p_sourcetext, and pg_mbstrlen_with_len().

Referenced by addRangeTableEntryForCTE(), addRangeTableEntryForFunction(), AlterDatabase(), analyzeCTE(), analyzeCTETargetList(), assign_collations_walker(), assign_hypothetical_collations(), check_agg_arguments(), check_agg_arguments_walker(), check_agglevels_and_constraints(), check_lateral_ref_ok(), check_nested_generated_walker(), check_new_partition_bound(), check_parameter_resolution_walker(), check_srf_call_placement(), check_ungrouped_columns_walker(), checkExprIsVarFree(), checkInsertTargets(), checkTargetlistEntrySQL92(), checkWellFormedRecursion(), checkWellFormedRecursionWalker(), coerce_to_boolean(), coerce_to_common_type(), coerce_to_specific_type_typmod(), colNameToVar(), compatible_oper(), compute_common_attribute(), compute_function_attributes(), ComputePartitionAttrs(), createdb(), CreateExtension(), CreateRole(), CreateTrigger(), DefineCollation(), DefineType(), DropDatabase(), emit_precedence_warnings(), errorMissingColumn(), errorMissingRTE(), ExecAlterDefaultPrivilegesStmt(), ExecAlterExtensionStmt(), ExecVacuum(), ExpandAllTables(), ExpandColumnRefStar(), ExplainQuery(), finalize_grouping_exprs_walker(), findTargetlistEntrySQL92(), fixed_paramref_hook(), GetColumnDefCollation(), init_params(), LookupOperName(), LookupTypeNameExtended(), LookupTypeNameOid(), make_distinct_op(), make_op(), make_row_comparison_op(), make_row_distinct_op(), make_scalar_array_op(), merge_collation_state(), op_error(), parseCheckAggregates(), ParseFuncOrColumn(), parser_coercion_errposition(), parseTypeString(), pcb_error_callback(), plpgsql_post_column_ref(), ProcessCopyOptions(), resolve_column_ref(), resolve_unique_index_expr(), scanNameSpaceForRefname(), scanNameSpaceForRelid(), scanRTEForColumn(), select_common_collation(), select_common_type(), TopologicalSort(), transformAExprNullIf(), transformAggregateCall(), transformArrayExpr(), transformAssignedExpr(), transformAssignmentIndirection(), transformAssignmentSubscripts(), transformCaseExpr(), transformCoalesceExpr(), transformCollateClause(), transformColumnDefinition(), transformColumnRef(), transformColumnType(), transformConstraintAttrs(), transformContainerSubscripts(), transformDistinctClause(), transformDistinctOnClause(), transformExprRecurse(), transformFrameOffset(), transformFromClauseItem(), transformGroupingFunc(), transformGroupingSet(), transformIndexConstraint(), transformIndirection(), transformInsertRow(), transformInsertStmt(), transformLockingClause(), transformMultiAssignRef(), transformOnConflictArbiter(), transformParamRef(), transformPartitionBound(), transformPartitionBoundValue(), transformRangeFunction(), transformRangeTableFunc(), transformRangeTableSample(), transformReturningList(), transformSelectStmt(), transformSetOperationStmt(), transformSetOperationTree(), transformSubLink(), transformTableConstraint(), transformUpdateTargetList(), transformValuesClause(), transformWindowDefinitions(), transformWindowFuncCall(), transformWithClause(), transformXmlExpr(), transformXmlSerialize(), typenameType(), typenameTypeMod(), unknown_attribute(), validateInfiniteBounds(), variable_coerce_param_hook(), and variable_paramref_hook().

111 {
112  int pos;
113 
114  /* No-op if location was not provided */
115  if (location < 0)
116  return 0;
117  /* Can't do anything if source text is not available */
118  if (pstate == NULL || pstate->p_sourcetext == NULL)
119  return 0;
120  /* Convert offset to character number */
121  pos = pg_mbstrlen_with_len(pstate->p_sourcetext, location) + 1;
122  /* And pass it to the ereport mechanism */
123  return errposition(pos);
124 }
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:836
const char * p_sourcetext
Definition: parse_node.h:176
int errposition(int cursorpos)
Definition: elog.c:1209

◆ pcb_error_callback()

static void pcb_error_callback ( void *  arg)
static

Definition at line 174 of file parse_node.c.

References geterrcode(), ParseCallbackState::location, parser_errposition(), and ParseCallbackState::pstate.

Referenced by setup_parser_errposition_callback().

175 {
176  ParseCallbackState *pcbstate = (ParseCallbackState *) arg;
177 
178  if (geterrcode() != ERRCODE_QUERY_CANCELED)
179  (void) parser_errposition(pcbstate->pstate, pcbstate->location);
180 }
int geterrcode(void)
Definition: elog.c:1324
ParseState * pstate
Definition: parse_node.h:261
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
void * arg

◆ setup_parser_errposition_callback()

void setup_parser_errposition_callback ( ParseCallbackState pcbstate,
ParseState pstate,
int  location 
)

Definition at line 144 of file parse_node.c.

References ErrorContextCallback::arg, ErrorContextCallback::callback, ParseCallbackState::errcallback, error_context_stack, ParseCallbackState::location, pcb_error_callback(), ErrorContextCallback::previous, and ParseCallbackState::pstate.

Referenced by addTargetToGroupList(), addTargetToSortList(), coerce_type(), LookupCollation(), LookupTypeNameExtended(), make_const(), make_oper_cache_key(), ParseFuncOrColumn(), parserOpenTable(), transformCreateStmt(), transformSetOperationTree(), transformTableLikeClause(), and typenameTypeMod().

146 {
147  /* Setup error traceback support for ereport() */
148  pcbstate->pstate = pstate;
149  pcbstate->location = location;
151  pcbstate->errcallback.arg = (void *) pcbstate;
153  error_context_stack = &pcbstate->errcallback;
154 }
ErrorContextCallback errcallback
Definition: parse_node.h:263
void(* callback)(void *arg)
Definition: elog.h:256
struct ErrorContextCallback * previous
Definition: elog.h:255
ErrorContextCallback * error_context_stack
Definition: elog.c:91
ParseState * pstate
Definition: parse_node.h:261
static void pcb_error_callback(void *arg)
Definition: parse_node.c:174

◆ transformContainerSubscripts()

SubscriptingRef* transformContainerSubscripts ( ParseState pstate,
Node containerBase,
Oid  containerType,
Oid  elementType,
int32  containerTypMod,
List indirection,
Node assignFrom 
)

Definition at line 297 of file parse_node.c.

References Assert, COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, ereport, errcode(), errhint(), errmsg(), ERROR, exprLocation(), exprType(), format_type_be(), idx(), Int32GetDatum, InvalidOid, A_Indices::is_slice, lappend(), lfirst, lfirst_node, A_Indices::lidx, makeConst(), makeNode, NIL, OidIsValid, ParseState::p_expr_kind, parser_errposition(), SubscriptingRef::refassgnexpr, SubscriptingRef::refcontainertype, SubscriptingRef::refelemtype, SubscriptingRef::refexpr, SubscriptingRef::reflowerindexpr, SubscriptingRef::reftypmod, SubscriptingRef::refupperindexpr, transformContainerType(), transformExpr(), and A_Indices::uidx.

Referenced by transformAssignmentSubscripts(), and transformIndirection().

304 {
305  bool isSlice = false;
306  List *upperIndexpr = NIL;
307  List *lowerIndexpr = NIL;
308  ListCell *idx;
309  SubscriptingRef *sbsref;
310 
311  /*
312  * Caller may or may not have bothered to determine elementType. Note
313  * that if the caller did do so, containerType/containerTypMod must be as
314  * modified by transformContainerType, ie, smash domain to base type.
315  */
316  if (!OidIsValid(elementType))
317  elementType = transformContainerType(&containerType, &containerTypMod);
318 
319  /*
320  * A list containing only simple subscripts refers to a single container
321  * element. If any of the items are slice specifiers (lower:upper), then
322  * the subscript expression means a container slice operation. In this
323  * case, we convert any non-slice items to slices by treating the single
324  * subscript as the upper bound and supplying an assumed lower bound of 1.
325  * We have to prescan the list to see if there are any slice items.
326  */
327  foreach(idx, indirection)
328  {
329  A_Indices *ai = (A_Indices *) lfirst(idx);
330 
331  if (ai->is_slice)
332  {
333  isSlice = true;
334  break;
335  }
336  }
337 
338  /*
339  * Transform the subscript expressions.
340  */
341  foreach(idx, indirection)
342  {
343  A_Indices *ai = lfirst_node(A_Indices, idx);
344  Node *subexpr;
345 
346  if (isSlice)
347  {
348  if (ai->lidx)
349  {
350  subexpr = transformExpr(pstate, ai->lidx, pstate->p_expr_kind);
351  /* If it's not int4 already, try to coerce */
352  subexpr = coerce_to_target_type(pstate,
353  subexpr, exprType(subexpr),
354  INT4OID, -1,
357  -1);
358  if (subexpr == NULL)
359  ereport(ERROR,
360  (errcode(ERRCODE_DATATYPE_MISMATCH),
361  errmsg("array subscript must have type integer"),
362  parser_errposition(pstate, exprLocation(ai->lidx))));
363  }
364  else if (!ai->is_slice)
365  {
366  /* Make a constant 1 */
367  subexpr = (Node *) makeConst(INT4OID,
368  -1,
369  InvalidOid,
370  sizeof(int32),
371  Int32GetDatum(1),
372  false,
373  true); /* pass by value */
374  }
375  else
376  {
377  /* Slice with omitted lower bound, put NULL into the list */
378  subexpr = NULL;
379  }
380  lowerIndexpr = lappend(lowerIndexpr, subexpr);
381  }
382  else
383  Assert(ai->lidx == NULL && !ai->is_slice);
384 
385  if (ai->uidx)
386  {
387  subexpr = transformExpr(pstate, ai->uidx, pstate->p_expr_kind);
388  /* If it's not int4 already, try to coerce */
389  subexpr = coerce_to_target_type(pstate,
390  subexpr, exprType(subexpr),
391  INT4OID, -1,
394  -1);
395  if (subexpr == NULL)
396  ereport(ERROR,
397  (errcode(ERRCODE_DATATYPE_MISMATCH),
398  errmsg("array subscript must have type integer"),
399  parser_errposition(pstate, exprLocation(ai->uidx))));
400  }
401  else
402  {
403  /* Slice with omitted upper bound, put NULL into the list */
404  Assert(isSlice && ai->is_slice);
405  subexpr = NULL;
406  }
407  upperIndexpr = lappend(upperIndexpr, subexpr);
408  }
409 
410  /*
411  * If doing an array store, coerce the source value to the right type.
412  * (This should agree with the coercion done by transformAssignedExpr.)
413  */
414  if (assignFrom != NULL)
415  {
416  Oid typesource = exprType(assignFrom);
417  Oid typeneeded = isSlice ? containerType : elementType;
418  Node *newFrom;
419 
420  newFrom = coerce_to_target_type(pstate,
421  assignFrom, typesource,
422  typeneeded, containerTypMod,
425  -1);
426  if (newFrom == NULL)
427  ereport(ERROR,
428  (errcode(ERRCODE_DATATYPE_MISMATCH),
429  errmsg("array assignment requires type %s"
430  " but expression is of type %s",
431  format_type_be(typeneeded),
432  format_type_be(typesource)),
433  errhint("You will need to rewrite or cast the expression."),
434  parser_errposition(pstate, exprLocation(assignFrom))));
435  assignFrom = newFrom;
436  }
437 
438  /*
439  * Ready to build the SubscriptingRef node.
440  */
442  if (assignFrom != NULL)
443  sbsref->refassgnexpr = (Expr *) assignFrom;
444 
445  sbsref->refcontainertype = containerType;
446  sbsref->refelemtype = elementType;
447  sbsref->reftypmod = containerTypMod;
448  /* refcollid will be set by parse_collate.c */
449  sbsref->refupperindexpr = upperIndexpr;
450  sbsref->reflowerindexpr = lowerIndexpr;
451  sbsref->refexpr = (Expr *) containerBase;
452  sbsref->refassgnexpr = (Expr *) assignFrom;
453 
454  return sbsref;
455 }
#define NIL
Definition: pg_list.h:65
int errhint(const char *fmt,...)
Definition: elog.c:1071
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1191
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:144
Definition: nodes.h:525
int errcode(int sqlerrcode)
Definition: elog.c:608
char * format_type_be(Oid type_oid)
Definition: format_type.c:326
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:263
unsigned int Oid
Definition: postgres_ext.h:31
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:297
List * refupperindexpr
Definition: primnodes.h:408
#define OidIsValid(objectId)
Definition: c.h:639
signed int int32
Definition: c.h:347
bool is_slice
Definition: parsenodes.h:382
#define ERROR
Definition: elog.h:43
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition: parse_coerce.c:78
#define lfirst_node(type, lc)
Definition: pg_list.h:193
#define ereport(elevel, rest)
Definition: elog.h:141
List * lappend(List *list, void *datum)
Definition: list.c:322
ParseExprKind p_expr_kind
Definition: parse_node.h:191
#define InvalidOid
Definition: postgres_ext.h:36
#define makeNode(_type_)
Definition: nodes.h:573
#define Assert(condition)
Definition: c.h:733
#define lfirst(lc)
Definition: pg_list.h:190
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
Node * lidx
Definition: parsenodes.h:383
Expr * refassgnexpr
Definition: primnodes.h:416
#define Int32GetDatum(X)
Definition: postgres.h:479
int errmsg(const char *fmt,...)
Definition: elog.c:822
List * reflowerindexpr
Definition: primnodes.h:410
Node * uidx
Definition: parsenodes.h:384
Oid refcontainertype
Definition: primnodes.h:404
Expr * refexpr
Definition: primnodes.h:413
Definition: pg_list.h:50
Oid transformContainerType(Oid *containerType, int32 *containerTypmod)
Definition: parse_node.c:216

◆ transformContainerType()

Oid transformContainerType ( Oid containerType,
int32 containerTypmod 
)

Definition at line 216 of file parse_node.c.

References elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), getBaseTypeAndTypmod(), GETSTRUCT, HeapTupleIsValid, InvalidOid, ObjectIdGetDatum, ReleaseSysCache(), SearchSysCache1(), and TYPEOID.

Referenced by transformAssignmentSubscripts(), and transformContainerSubscripts().

217 {
218  Oid origContainerType = *containerType;
219  Oid elementType;
220  HeapTuple type_tuple_container;
221  Form_pg_type type_struct_container;
222 
223  /*
224  * If the input is a domain, smash to base type, and extract the actual
225  * typmod to be applied to the base type. Subscripting a domain is an
226  * operation that necessarily works on the base container type, not the
227  * domain itself. (Note that we provide no method whereby the creator of a
228  * domain over a container type could hide its ability to be subscripted.)
229  */
230  *containerType = getBaseTypeAndTypmod(*containerType, containerTypmod);
231 
232  /*
233  * Here is an array specific code. We treat int2vector and oidvector as
234  * though they were domains over int2[] and oid[]. This is needed because
235  * array slicing could create an array that doesn't satisfy the
236  * dimensionality constraints of the xxxvector type; so we want the result
237  * of a slice operation to be considered to be of the more general type.
238  */
239  if (*containerType == INT2VECTOROID)
240  *containerType = INT2ARRAYOID;
241  else if (*containerType == OIDVECTOROID)
242  *containerType = OIDARRAYOID;
243 
244  /* Get the type tuple for the container */
245  type_tuple_container = SearchSysCache1(TYPEOID, ObjectIdGetDatum(*containerType));
246  if (!HeapTupleIsValid(type_tuple_container))
247  elog(ERROR, "cache lookup failed for type %u", *containerType);
248  type_struct_container = (Form_pg_type) GETSTRUCT(type_tuple_container);
249 
250  /* needn't check typisdefined since this will fail anyway */
251 
252  elementType = type_struct_container->typelem;
253  if (elementType == InvalidOid)
254  ereport(ERROR,
255  (errcode(ERRCODE_DATATYPE_MISMATCH),
256  errmsg("cannot subscript type %s because it is not an array",
257  format_type_be(origContainerType))));
258 
259  ReleaseSysCache(type_tuple_container);
260 
261  return elementType;
262 }
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2316
#define GETSTRUCT(TUP)
Definition: htup_details.h:655
int errcode(int sqlerrcode)
Definition: elog.c:608
char * format_type_be(Oid type_oid)
Definition: format_type.c:326
unsigned int Oid
Definition: postgres_ext.h:31
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:141
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1116
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1164
#define InvalidOid
Definition: postgres_ext.h:36
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
FormData_pg_type * Form_pg_type
Definition: pg_type.h:251
int errmsg(const char *fmt,...)
Definition: elog.c:822
#define elog(elevel,...)
Definition: elog.h:228