PostgreSQL Source Code  git master
Data Structures | Macros | Typedefs | Enumerations | Functions
execExpr.h File Reference
#include "executor/nodeAgg.h"
#include "nodes/execnodes.h"
Include dependency graph for execExpr.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  ExprEvalStep
 
struct  SubscriptingRefState
 

Macros

#define EEO_FLAG_INTERPRETER_INITIALIZED   (1 << 1)
 
#define EEO_FLAG_DIRECT_THREADED   (1 << 2)
 

Typedefs

typedef void(* ExecEvalSubroutine) (ExprState *state, struct ExprEvalStep *op, ExprContext *econtext)
 
typedef enum ExprEvalOp ExprEvalOp
 
typedef struct ExprEvalStep ExprEvalStep
 
typedef struct SubscriptingRefState SubscriptingRefState
 

Enumerations

enum  ExprEvalOp {
  EEOP_DONE, EEOP_INNER_FETCHSOME, EEOP_OUTER_FETCHSOME, EEOP_SCAN_FETCHSOME,
  EEOP_INNER_VAR, EEOP_OUTER_VAR, EEOP_SCAN_VAR, EEOP_INNER_SYSVAR,
  EEOP_OUTER_SYSVAR, EEOP_SCAN_SYSVAR, EEOP_WHOLEROW, EEOP_ASSIGN_INNER_VAR,
  EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_ASSIGN_TMP, EEOP_ASSIGN_TMP_MAKE_RO,
  EEOP_CONST, EEOP_FUNCEXPR, EEOP_FUNCEXPR_STRICT, EEOP_FUNCEXPR_FUSAGE,
  EEOP_FUNCEXPR_STRICT_FUSAGE, EEOP_BOOL_AND_STEP_FIRST, EEOP_BOOL_AND_STEP, EEOP_BOOL_AND_STEP_LAST,
  EEOP_BOOL_OR_STEP_FIRST, EEOP_BOOL_OR_STEP, EEOP_BOOL_OR_STEP_LAST, EEOP_BOOL_NOT_STEP,
  EEOP_QUAL, EEOP_JUMP, EEOP_JUMP_IF_NULL, EEOP_JUMP_IF_NOT_NULL,
  EEOP_JUMP_IF_NOT_TRUE, EEOP_NULLTEST_ISNULL, EEOP_NULLTEST_ISNOTNULL, EEOP_NULLTEST_ROWISNULL,
  EEOP_NULLTEST_ROWISNOTNULL, EEOP_BOOLTEST_IS_TRUE, EEOP_BOOLTEST_IS_NOT_TRUE, EEOP_BOOLTEST_IS_FALSE,
  EEOP_BOOLTEST_IS_NOT_FALSE, EEOP_PARAM_EXEC, EEOP_PARAM_EXTERN, EEOP_PARAM_CALLBACK,
  EEOP_CASE_TESTVAL, EEOP_MAKE_READONLY, EEOP_IOCOERCE, EEOP_DISTINCT,
  EEOP_NOT_DISTINCT, EEOP_NULLIF, EEOP_SQLVALUEFUNCTION, EEOP_CURRENTOFEXPR,
  EEOP_NEXTVALUEEXPR, EEOP_ARRAYEXPR, EEOP_ARRAYCOERCE, EEOP_ROW,
  EEOP_ROWCOMPARE_STEP, EEOP_ROWCOMPARE_FINAL, EEOP_MINMAX, EEOP_FIELDSELECT,
  EEOP_FIELDSTORE_DEFORM, EEOP_FIELDSTORE_FORM, EEOP_SBSREF_SUBSCRIPT, EEOP_SBSREF_OLD,
  EEOP_SBSREF_ASSIGN, EEOP_SBSREF_FETCH, EEOP_DOMAIN_TESTVAL, EEOP_DOMAIN_NOTNULL,
  EEOP_DOMAIN_CHECK, EEOP_CONVERT_ROWTYPE, EEOP_SCALARARRAYOP, EEOP_XMLEXPR,
  EEOP_AGGREF, EEOP_GROUPING_FUNC, EEOP_WINDOW_FUNC, EEOP_SUBPLAN,
  EEOP_AGG_STRICT_DESERIALIZE, EEOP_AGG_DESERIALIZE, EEOP_AGG_STRICT_INPUT_CHECK_ARGS, EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
  EEOP_AGG_PLAIN_PERGROUP_NULLCHECK, EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL, EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL, EEOP_AGG_PLAIN_TRANS_BYVAL,
  EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF, EEOP_AGG_PLAIN_TRANS_STRICT_BYREF, EEOP_AGG_PLAIN_TRANS_BYREF, EEOP_AGG_ORDERED_TRANS_DATUM,
  EEOP_AGG_ORDERED_TRANS_TUPLE, EEOP_LAST
}
 

Functions

void ExprEvalPushStep (ExprState *es, const ExprEvalStep *s)
 
void ExecReadyInterpretedExpr (ExprState *state)
 
ExprEvalOp ExecEvalStepOp (ExprState *state, ExprEvalStep *op)
 
Datum ExecInterpExprStillValid (ExprState *state, ExprContext *econtext, bool *isNull)
 
void CheckExprStillValid (ExprState *state, ExprContext *econtext)
 
void ExecEvalFuncExprFusage (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalFuncExprStrictFusage (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalParamExec (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalParamExtern (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalSQLValueFunction (ExprState *state, ExprEvalStep *op)
 
void ExecEvalCurrentOfExpr (ExprState *state, ExprEvalStep *op)
 
void ExecEvalNextValueExpr (ExprState *state, ExprEvalStep *op)
 
void ExecEvalRowNull (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalRowNotNull (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalArrayExpr (ExprState *state, ExprEvalStep *op)
 
void ExecEvalArrayCoerce (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalRow (ExprState *state, ExprEvalStep *op)
 
void ExecEvalMinMax (ExprState *state, ExprEvalStep *op)
 
void ExecEvalFieldSelect (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalFieldStoreDeForm (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalFieldStoreForm (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
bool ExecEvalSubscriptingRef (ExprState *state, ExprEvalStep *op)
 
void ExecEvalSubscriptingRefFetch (ExprState *state, ExprEvalStep *op)
 
void ExecEvalSubscriptingRefOld (ExprState *state, ExprEvalStep *op)
 
void ExecEvalSubscriptingRefAssign (ExprState *state, ExprEvalStep *op)
 
void ExecEvalConvertRowtype (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalScalarArrayOp (ExprState *state, ExprEvalStep *op)
 
void ExecEvalConstraintNotNull (ExprState *state, ExprEvalStep *op)
 
void ExecEvalConstraintCheck (ExprState *state, ExprEvalStep *op)
 
void ExecEvalXmlExpr (ExprState *state, ExprEvalStep *op)
 
void ExecEvalGroupingFunc (ExprState *state, ExprEvalStep *op)
 
void ExecEvalSubPlan (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalWholeRowVar (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalSysVar (ExprState *state, ExprEvalStep *op, ExprContext *econtext, TupleTableSlot *slot)
 
void ExecAggInitGroup (AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext *aggcontext)
 
Datum ExecAggTransReparent (AggState *aggstate, AggStatePerTrans pertrans, Datum newValue, bool newValueIsNull, Datum oldValue, bool oldValueIsNull)
 
void ExecEvalAggOrderedTransDatum (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 
void ExecEvalAggOrderedTransTuple (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
 

Macro Definition Documentation

◆ EEO_FLAG_DIRECT_THREADED

#define EEO_FLAG_DIRECT_THREADED   (1 << 2)

Definition at line 28 of file execExpr.h.

Referenced by ExecEvalStepOp(), and ExecReadyInterpretedExpr().

◆ EEO_FLAG_INTERPRETER_INITIALIZED

#define EEO_FLAG_INTERPRETER_INITIALIZED   (1 << 1)

Definition at line 26 of file execExpr.h.

Referenced by ExecReadyInterpretedExpr().

Typedef Documentation

◆ ExecEvalSubroutine

typedef void(* ExecEvalSubroutine) (ExprState *state, struct ExprEvalStep *op, ExprContext *econtext)

Definition at line 31 of file execExpr.h.

◆ ExprEvalOp

typedef enum ExprEvalOp ExprEvalOp

◆ ExprEvalStep

typedef struct ExprEvalStep ExprEvalStep

◆ SubscriptingRefState

typedef struct SubscriptingRefState SubscriptingRefState

Enumeration Type Documentation

◆ ExprEvalOp

enum ExprEvalOp
Enumerator
EEOP_DONE 
EEOP_INNER_FETCHSOME 
EEOP_OUTER_FETCHSOME 
EEOP_SCAN_FETCHSOME 
EEOP_INNER_VAR 
EEOP_OUTER_VAR 
EEOP_SCAN_VAR 
EEOP_INNER_SYSVAR 
EEOP_OUTER_SYSVAR 
EEOP_SCAN_SYSVAR 
EEOP_WHOLEROW 
EEOP_ASSIGN_INNER_VAR 
EEOP_ASSIGN_OUTER_VAR 
EEOP_ASSIGN_SCAN_VAR 
EEOP_ASSIGN_TMP 
EEOP_ASSIGN_TMP_MAKE_RO 
EEOP_CONST 
EEOP_FUNCEXPR 
EEOP_FUNCEXPR_STRICT 
EEOP_FUNCEXPR_FUSAGE 
EEOP_FUNCEXPR_STRICT_FUSAGE 
EEOP_BOOL_AND_STEP_FIRST 
EEOP_BOOL_AND_STEP 
EEOP_BOOL_AND_STEP_LAST 
EEOP_BOOL_OR_STEP_FIRST 
EEOP_BOOL_OR_STEP 
EEOP_BOOL_OR_STEP_LAST 
EEOP_BOOL_NOT_STEP 
EEOP_QUAL 
EEOP_JUMP 
EEOP_JUMP_IF_NULL 
EEOP_JUMP_IF_NOT_NULL 
EEOP_JUMP_IF_NOT_TRUE 
EEOP_NULLTEST_ISNULL 
EEOP_NULLTEST_ISNOTNULL 
EEOP_NULLTEST_ROWISNULL 
EEOP_NULLTEST_ROWISNOTNULL 
EEOP_BOOLTEST_IS_TRUE 
EEOP_BOOLTEST_IS_NOT_TRUE 
EEOP_BOOLTEST_IS_FALSE 
EEOP_BOOLTEST_IS_NOT_FALSE 
EEOP_PARAM_EXEC 
EEOP_PARAM_EXTERN 
EEOP_PARAM_CALLBACK 
EEOP_CASE_TESTVAL 
EEOP_MAKE_READONLY 
EEOP_IOCOERCE 
EEOP_DISTINCT 
EEOP_NOT_DISTINCT 
EEOP_NULLIF 
EEOP_SQLVALUEFUNCTION 
EEOP_CURRENTOFEXPR 
EEOP_NEXTVALUEEXPR 
EEOP_ARRAYEXPR 
EEOP_ARRAYCOERCE 
EEOP_ROW 
EEOP_ROWCOMPARE_STEP 
EEOP_ROWCOMPARE_FINAL 
EEOP_MINMAX 
EEOP_FIELDSELECT 
EEOP_FIELDSTORE_DEFORM 
EEOP_FIELDSTORE_FORM 
EEOP_SBSREF_SUBSCRIPT 
EEOP_SBSREF_OLD 
EEOP_SBSREF_ASSIGN 
EEOP_SBSREF_FETCH 
EEOP_DOMAIN_TESTVAL 
EEOP_DOMAIN_NOTNULL 
EEOP_DOMAIN_CHECK 
EEOP_CONVERT_ROWTYPE 
EEOP_SCALARARRAYOP 
EEOP_XMLEXPR 
EEOP_AGGREF 
EEOP_GROUPING_FUNC 
EEOP_WINDOW_FUNC 
EEOP_SUBPLAN 
EEOP_AGG_STRICT_DESERIALIZE 
EEOP_AGG_DESERIALIZE 
EEOP_AGG_STRICT_INPUT_CHECK_ARGS 
EEOP_AGG_STRICT_INPUT_CHECK_NULLS 
EEOP_AGG_PLAIN_PERGROUP_NULLCHECK 
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL 
EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL 
EEOP_AGG_PLAIN_TRANS_BYVAL 
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF 
EEOP_AGG_PLAIN_TRANS_STRICT_BYREF 
EEOP_AGG_PLAIN_TRANS_BYREF 
EEOP_AGG_ORDERED_TRANS_DATUM 
EEOP_AGG_ORDERED_TRANS_TUPLE 
EEOP_LAST 

Definition at line 44 of file execExpr.h.

45 {
46  /* entire expression has been evaluated completely, return */
47  EEOP_DONE,
48 
49  /* apply slot_getsomeattrs on corresponding tuple slot */
50  EEOP_INNER_FETCHSOME,
51  EEOP_OUTER_FETCHSOME,
52  EEOP_SCAN_FETCHSOME,
53 
54  /* compute non-system Var value */
55  EEOP_INNER_VAR,
56  EEOP_OUTER_VAR,
57  EEOP_SCAN_VAR,
58 
59  /* compute system Var value */
60  EEOP_INNER_SYSVAR,
61  EEOP_OUTER_SYSVAR,
62  EEOP_SCAN_SYSVAR,
63 
64  /* compute wholerow Var */
65  EEOP_WHOLEROW,
66 
67  /*
68  * Compute non-system Var value, assign it into ExprState's resultslot.
69  * These are not used if a CheckVarSlotCompatibility() check would be
70  * needed.
71  */
72  EEOP_ASSIGN_INNER_VAR,
73  EEOP_ASSIGN_OUTER_VAR,
74  EEOP_ASSIGN_SCAN_VAR,
75 
76  /* assign ExprState's resvalue/resnull to a column of its resultslot */
77  EEOP_ASSIGN_TMP,
78  /* ditto, applying MakeExpandedObjectReadOnly() */
79  EEOP_ASSIGN_TMP_MAKE_RO,
80 
81  /* evaluate Const value */
82  EEOP_CONST,
83 
84  /*
85  * Evaluate function call (including OpExprs etc). For speed, we
86  * distinguish in the opcode whether the function is strict and/or
87  * requires usage stats tracking.
88  */
89  EEOP_FUNCEXPR,
90  EEOP_FUNCEXPR_STRICT,
91  EEOP_FUNCEXPR_FUSAGE,
92  EEOP_FUNCEXPR_STRICT_FUSAGE,
93 
94  /*
95  * Evaluate boolean AND expression, one step per subexpression. FIRST/LAST
96  * subexpressions are special-cased for performance. Since AND always has
97  * at least two subexpressions, FIRST and LAST never apply to the same
98  * subexpression.
99  */
100  EEOP_BOOL_AND_STEP_FIRST,
101  EEOP_BOOL_AND_STEP,
102  EEOP_BOOL_AND_STEP_LAST,
103 
104  /* similarly for boolean OR expression */
105  EEOP_BOOL_OR_STEP_FIRST,
106  EEOP_BOOL_OR_STEP,
107  EEOP_BOOL_OR_STEP_LAST,
108 
109  /* evaluate boolean NOT expression */
110  EEOP_BOOL_NOT_STEP,
111 
112  /* simplified version of BOOL_AND_STEP for use by ExecQual() */
113  EEOP_QUAL,
114 
115  /* unconditional jump to another step */
116  EEOP_JUMP,
117 
118  /* conditional jumps based on current result value */
119  EEOP_JUMP_IF_NULL,
120  EEOP_JUMP_IF_NOT_NULL,
121  EEOP_JUMP_IF_NOT_TRUE,
122 
123  /* perform NULL tests for scalar values */
124  EEOP_NULLTEST_ISNULL,
125  EEOP_NULLTEST_ISNOTNULL,
126 
127  /* perform NULL tests for row values */
128  EEOP_NULLTEST_ROWISNULL,
129  EEOP_NULLTEST_ROWISNOTNULL,
130 
131  /* evaluate a BooleanTest expression */
132  EEOP_BOOLTEST_IS_TRUE,
133  EEOP_BOOLTEST_IS_NOT_TRUE,
134  EEOP_BOOLTEST_IS_FALSE,
135  EEOP_BOOLTEST_IS_NOT_FALSE,
136 
137  /* evaluate PARAM_EXEC/EXTERN parameters */
138  EEOP_PARAM_EXEC,
139  EEOP_PARAM_EXTERN,
140  EEOP_PARAM_CALLBACK,
141 
142  /* return CaseTestExpr value */
143  EEOP_CASE_TESTVAL,
144 
145  /* apply MakeExpandedObjectReadOnly() to target value */
146  EEOP_MAKE_READONLY,
147 
148  /* evaluate assorted special-purpose expression types */
149  EEOP_IOCOERCE,
150  EEOP_DISTINCT,
151  EEOP_NOT_DISTINCT,
152  EEOP_NULLIF,
153  EEOP_SQLVALUEFUNCTION,
154  EEOP_CURRENTOFEXPR,
155  EEOP_NEXTVALUEEXPR,
156  EEOP_ARRAYEXPR,
157  EEOP_ARRAYCOERCE,
158  EEOP_ROW,
159 
160  /*
161  * Compare two individual elements of each of two compared ROW()
162  * expressions. Skip to ROWCOMPARE_FINAL if elements are not equal.
163  */
164  EEOP_ROWCOMPARE_STEP,
165 
166  /* evaluate boolean value based on previous ROWCOMPARE_STEP operations */
167  EEOP_ROWCOMPARE_FINAL,
168 
169  /* evaluate GREATEST() or LEAST() */
170  EEOP_MINMAX,
171 
172  /* evaluate FieldSelect expression */
173  EEOP_FIELDSELECT,
174 
175  /*
176  * Deform tuple before evaluating new values for individual fields in a
177  * FieldStore expression.
178  */
179  EEOP_FIELDSTORE_DEFORM,
180 
181  /*
182  * Form the new tuple for a FieldStore expression. Individual fields will
183  * have been evaluated into columns of the tuple deformed by the preceding
184  * DEFORM step.
185  */
186  EEOP_FIELDSTORE_FORM,
187 
188  /* Process a container subscript; short-circuit expression to NULL if NULL */
189  EEOP_SBSREF_SUBSCRIPT,
190 
191  /*
192  * Compute old container element/slice when a SubscriptingRef assignment
193  * expression contains SubscriptingRef/FieldStore subexpressions. Value is
194  * accessed using the CaseTest mechanism.
195  */
196  EEOP_SBSREF_OLD,
197 
198  /* compute new value for SubscriptingRef assignment expression */
199  EEOP_SBSREF_ASSIGN,
200 
201  /* compute element/slice for SubscriptingRef fetch expression */
202  EEOP_SBSREF_FETCH,
203 
204  /* evaluate value for CoerceToDomainValue */
205  EEOP_DOMAIN_TESTVAL,
206 
207  /* evaluate a domain's NOT NULL constraint */
208  EEOP_DOMAIN_NOTNULL,
209 
210  /* evaluate a single domain CHECK constraint */
211  EEOP_DOMAIN_CHECK,
212 
213  /* evaluate assorted special-purpose expression types */
214  EEOP_CONVERT_ROWTYPE,
215  EEOP_SCALARARRAYOP,
216  EEOP_XMLEXPR,
217  EEOP_AGGREF,
218  EEOP_GROUPING_FUNC,
219  EEOP_WINDOW_FUNC,
220  EEOP_SUBPLAN,
221 
222  /* aggregation related nodes */
223  EEOP_AGG_STRICT_DESERIALIZE,
224  EEOP_AGG_DESERIALIZE,
225  EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
226  EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
227  EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
228  EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,
229  EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL,
230  EEOP_AGG_PLAIN_TRANS_BYVAL,
231  EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF,
232  EEOP_AGG_PLAIN_TRANS_STRICT_BYREF,
233  EEOP_AGG_PLAIN_TRANS_BYREF,
234  EEOP_AGG_ORDERED_TRANS_DATUM,
235  EEOP_AGG_ORDERED_TRANS_TUPLE,
236 
237  /* non-existent operation, used e.g. to check array lengths */
238  EEOP_LAST
239 } ExprEvalOp;
ExprEvalOp
ExprEvalOp
Definition: execExpr.h:44

Function Documentation

◆ CheckExprStillValid()

void CheckExprStillValid ( ExprState *  state,
ExprContext *  econtext 
)

Definition at line 1801 of file execExprInterp.c.

References attnum, CheckVarSlotCompatibility(), ExprEvalStep::d, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_scantuple, EEOP_INNER_VAR, EEOP_OUTER_VAR, EEOP_SCAN_VAR, ExecEvalStepOp(), i, ExprState::steps, ExprState::steps_len, and ExprEvalStep::var.

Referenced by ExecInterpExprStillValid(), and ExecRunCompiledExpr().

1802 {
1803  TupleTableSlot *innerslot;
1804  TupleTableSlot *outerslot;
1805  TupleTableSlot *scanslot;
1806 
1807  innerslot = econtext->ecxt_innertuple;
1808  outerslot = econtext->ecxt_outertuple;
1809  scanslot = econtext->ecxt_scantuple;
1810 
1811  for (int i = 0; i < state->steps_len; i++)
1812  {
1813  ExprEvalStep *op = &state->steps[i];
1814 
1815  switch (ExecEvalStepOp(state, op))
1816  {
1817  case EEOP_INNER_VAR:
1818  {
1819  int attnum = op->d.var.attnum;
1820 
1821  CheckVarSlotCompatibility(innerslot, attnum + 1, op->d.var.vartype);
1822  break;
1823  }
1824 
1825  case EEOP_OUTER_VAR:
1826  {
1827  int attnum = op->d.var.attnum;
1828 
1829  CheckVarSlotCompatibility(outerslot, attnum + 1, op->d.var.vartype);
1830  break;
1831  }
1832 
1833  case EEOP_SCAN_VAR:
1834  {
1835  int attnum = op->d.var.attnum;
1836 
1837  CheckVarSlotCompatibility(scanslot, attnum + 1, op->d.var.vartype);
1838  break;
1839  }
1840  default:
1841  break;
1842  }
1843  }
1844 }
ExprState::steps
struct ExprEvalStep * steps
Definition: execnodes.h:84
CheckVarSlotCompatibility
static void CheckVarSlotCompatibility(TupleTableSlot *slot, int attnum, Oid vartype)
Definition: execExprInterp.c:1852
ExecEvalStepOp
ExprEvalOp ExecEvalStepOp(ExprState *state, ExprEvalStep *op)
Definition: execExprInterp.c:2262
ExprContext::ecxt_innertuple
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:227
ExprEvalStep::d
union ExprEvalStep::@51 d
ExprEvalStep::var
struct ExprEvalStep::@51::@53 var
attnum
int16 attnum
Definition: pg_attribute.h:79
ExprContext::ecxt_outertuple
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:229
ExprContext::ecxt_scantuple
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:225
ExprState::steps_len
int steps_len
Definition: execnodes.h:103
i
int i
Definition: preproc-comment.c:23

◆ ExecAggInitGroup()

void ExecAggInitGroup ( AggState *  aggstate,
AggStatePerTrans  pertrans,
AggStatePerGroup  pergroup,
ExprContext *  aggcontext 
)

Definition at line 4118 of file execExprInterp.c.

References FunctionCallInfoBaseData::args, datumCopy(), ExprContext::ecxt_per_tuple_memory, MemoryContextSwitchTo(), AggStatePerGroupData::noTransValue, AggStatePerTransData::transfn_fcinfo, AggStatePerTransData::transtypeByVal, AggStatePerTransData::transtypeLen, AggStatePerGroupData::transValue, AggStatePerGroupData::transValueIsNull, and NullableDatum::value.

Referenced by ExecInterpExpr().

4120 {
4121  FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
4122  MemoryContext oldContext;
4123 
4124  /*
4125  * We must copy the datum into aggcontext if it is pass-by-ref. We do not
4126  * need to pfree the old transValue, since it's NULL. (We already checked
4127  * that the agg's input type is binary-compatible with its transtype, so
4128  * straight copy here is OK.)
4129  */
4130  oldContext = MemoryContextSwitchTo(aggcontext->ecxt_per_tuple_memory);
4131  pergroup->transValue = datumCopy(fcinfo->args[1].value,
4132  pertrans->transtypeByVal,
4133  pertrans->transtypeLen);
4134  pergroup->transValueIsNull = false;
4135  pergroup->noTransValue = false;
4136  MemoryContextSwitchTo(oldContext);
4137 }
ExprContext::ecxt_per_tuple_memory
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:233
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
AggStatePerTransData::transfn_fcinfo
FunctionCallInfo transfn_fcinfo
Definition: nodeAgg.h:162
FunctionCallInfoBaseData::args
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
NullableDatum::value
Datum value
Definition: postgres.h:378
datumCopy
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:131

◆ ExecAggTransReparent()

Datum ExecAggTransReparent ( AggState *  aggstate,
AggStatePerTrans  pertrans,
Datum  newValue,
bool  newValueIsNull,
Datum  oldValue,
bool  oldValueIsNull 
)

Definition at line 4146 of file execExprInterp.c.

References Assert, AggState::curaggcontext, CurrentMemoryContext, datumCopy(), DatumGetEOHP(), DatumGetPointer, DatumIsReadWriteExpandedObject, DeleteExpandedObject(), ExprContext::ecxt_per_tuple_memory, MemoryContextGetParent(), MemoryContextSwitchTo(), pfree(), AggStatePerTransData::transtypeByVal, and AggStatePerTransData::transtypeLen.

Referenced by advance_transition_function(), and ExecAggPlainTransByRef().

4149 {
4150  Assert(newValue != oldValue);
4151 
4152  if (!newValueIsNull)
4153  {
4154  MemoryContextSwitchTo(aggstate->curaggcontext->ecxt_per_tuple_memory);
4155  if (DatumIsReadWriteExpandedObject(newValue,
4156  false,
4157  pertrans->transtypeLen) &&
4158  MemoryContextGetParent(DatumGetEOHP(newValue)->eoh_context) == CurrentMemoryContext)
4159  /* do nothing */ ;
4160  else
4161  newValue = datumCopy(newValue,
4162  pertrans->transtypeByVal,
4163  pertrans->transtypeLen);
4164  }
4165  else
4166  {
4167  /*
4168  * Ensure that AggStatePerGroup->transValue ends up being 0, so
4169  * callers can safely compare newValue/oldValue without having to
4170  * check their respective nullness.
4171  */
4172  newValue = (Datum) 0;
4173  }
4174 
4175  if (!oldValueIsNull)
4176  {
4177  if (DatumIsReadWriteExpandedObject(oldValue,
4178  false,
4179  pertrans->transtypeLen))
4180  DeleteExpandedObject(oldValue);
4181  else
4182  pfree(DatumGetPointer(oldValue));
4183  }
4184 
4185  return newValue;
4186 }
MemoryContextGetParent
MemoryContext MemoryContextGetParent(MemoryContext context)
Definition: mcxt.c:440
ExprContext::ecxt_per_tuple_memory
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:233
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
datumCopy
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:131
DatumGetEOHP
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
AggState::curaggcontext
ExprContext * curaggcontext
Definition: execnodes.h:2158
Datum
uintptr_t Datum
Definition: postgres.h:367
DeleteExpandedObject
void DeleteExpandedObject(Datum d)
Definition: expandeddatum.c:136
Assert
#define Assert(condition)
Definition: c.h:746
DatumIsReadWriteExpandedObject
#define DatumIsReadWriteExpandedObject(d, isnull, typlen)
Definition: expandeddatum.h:140
DatumGetPointer
#define DatumGetPointer(X)
Definition: postgres.h:549

◆ ExecEvalAggOrderedTransDatum()

void ExecEvalAggOrderedTransDatum ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 4192 of file execExprInterp.c.

References ExprEvalStep::agg_trans, ExprEvalStep::d, ExprEvalStep::resnull, ExprEvalStep::resvalue, AggStatePerTransData::sortstates, and tuplesort_putdatum().

Referenced by ExecInterpExpr().

4194 {
4195  AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
4196  int setno = op->d.agg_trans.setno;
4197 
4198  tuplesort_putdatum(pertrans->sortstates[setno],
4199  *op->resvalue, *op->resnull);
4200 }
tuplesort_putdatum
void tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
Definition: tuplesort.c:1786
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::agg_trans
struct ExprEvalStep::@51::@91 agg_trans
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
AggStatePerTransData::sortstates
Tuplesortstate ** sortstates
Definition: nodeAgg.h:154
ExprEvalStep::d
union ExprEvalStep::@51 d

◆ ExecEvalAggOrderedTransTuple()

void ExecEvalAggOrderedTransTuple ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 4206 of file execExprInterp.c.

References ExprEvalStep::agg_trans, ExprEvalStep::d, ExecClearTuple(), ExecStoreVirtualTuple(), AggStatePerTransData::numInputs, pg_attribute_always_inline, AggStatePerTransData::sortslot, AggStatePerTransData::sortstates, TupleTableSlot::tts_nvalid, and tuplesort_puttupleslot().

Referenced by ExecInterpExpr().

4208 {
4209  AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
4210  int setno = op->d.agg_trans.setno;
4211 
4212  ExecClearTuple(pertrans->sortslot);
4213  pertrans->sortslot->tts_nvalid = pertrans->numInputs;
4214  ExecStoreVirtualTuple(pertrans->sortslot);
4215  tuplesort_puttupleslot(pertrans->sortstates[setno], pertrans->sortslot);
4216 }
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
ExprEvalStep::agg_trans
struct ExprEvalStep::@51::@91 agg_trans
AggStatePerTransData::sortstates
Tuplesortstate ** sortstates
Definition: nodeAgg.h:154
ExprEvalStep::d
union ExprEvalStep::@51 d
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition: tuptable.h:121
AggStatePerTransData::sortslot
TupleTableSlot * sortslot
Definition: nodeAgg.h:136
ExecStoreVirtualTuple
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522
tuplesort_puttupleslot
void tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
Definition: tuplesort.c:1665

◆ ExecEvalArrayCoerce()

void ExecEvalArrayCoerce ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2826 of file execExprInterp.c.

References ARR_ELEMTYPE, array_map(), ExprEvalStep::arraycoerce, ExprEvalStep::d, DatumGetArrayTypePCopy, PointerGetDatum, ExprEvalStep::resnull, and ExprEvalStep::resvalue.

Referenced by ExecInterpExpr().

2827 {
2828  Datum arraydatum;
2829 
2830  /* NULL array -> NULL result */
2831  if (*op->resnull)
2832  return;
2833 
2834  arraydatum = *op->resvalue;
2835 
2836  /*
2837  * If it's binary-compatible, modify the element type in the array header,
2838  * but otherwise leave the array as we received it.
2839  */
2840  if (op->d.arraycoerce.elemexprstate == NULL)
2841  {
2842  /* Detoast input array if necessary, and copy in any case */
2843  ArrayType *array = DatumGetArrayTypePCopy(arraydatum);
2844 
2845  ARR_ELEMTYPE(array) = op->d.arraycoerce.resultelemtype;
2846  *op->resvalue = PointerGetDatum(array);
2847  return;
2848  }
2849 
2850  /*
2851  * Use array_map to apply the sub-expression to each array element.
2852  */
2853  *op->resvalue = array_map(arraydatum,
2854  op->d.arraycoerce.elemexprstate,
2855  econtext,
2856  op->d.arraycoerce.resultelemtype,
2857  op->d.arraycoerce.amstate);
2858 }
ExprEvalStep::arraycoerce
struct ExprEvalStep::@51::@71 arraycoerce
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
PointerGetDatum
#define PointerGetDatum(X)
Definition: postgres.h:556
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ExprEvalStep::d
union ExprEvalStep::@51 d
Datum
uintptr_t Datum
Definition: postgres.h:367
DatumGetArrayTypePCopy
#define DatumGetArrayTypePCopy(X)
Definition: array.h:250
array_map
Datum array_map(Datum arrayd, ExprState *exprstate, ExprContext *econtext, Oid retType, ArrayMapState *amstate)
Definition: arrayfuncs.c:3153
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition: array.h:280

◆ ExecEvalArrayExpr()

void ExecEvalArrayExpr ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 2621 of file execExprInterp.c.

References ARR_DATA_OFFSET, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ARR_SIZE, array_bitmap_copy(), ExprEvalStep::arrayexpr, ArrayGetNItems(), construct_empty_array(), construct_md_array(), ExprEvalStep::d, ArrayType::dataoffset, DatumGetArrayTypeP, ArrayType::elemtype, ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_be(), i, MAXDIM, ArrayType::ndim, palloc(), PointerGetDatum, ExprEvalStep::resnull, ExprEvalStep::resvalue, and SET_VARSIZE.

Referenced by ExecInterpExpr().

2622 {
2623  ArrayType *result;
2624  Oid element_type = op->d.arrayexpr.elemtype;
2625  int nelems = op->d.arrayexpr.nelems;
2626  int ndims = 0;
2627  int dims[MAXDIM];
2628  int lbs[MAXDIM];
2629 
2630  /* Set non-null as default */
2631  *op->resnull = false;
2632 
2633  if (!op->d.arrayexpr.multidims)
2634  {
2635  /* Elements are presumably of scalar type */
2636  Datum *dvalues = op->d.arrayexpr.elemvalues;
2637  bool *dnulls = op->d.arrayexpr.elemnulls;
2638 
2639  /* setup for 1-D array of the given length */
2640  ndims = 1;
2641  dims[0] = nelems;
2642  lbs[0] = 1;
2643 
2644  result = construct_md_array(dvalues, dnulls, ndims, dims, lbs,
2645  element_type,
2646  op->d.arrayexpr.elemlength,
2647  op->d.arrayexpr.elembyval,
2648  op->d.arrayexpr.elemalign);
2649  }
2650  else
2651  {
2652  /* Must be nested array expressions */
2653  int nbytes = 0;
2654  int nitems = 0;
2655  int outer_nelems = 0;
2656  int elem_ndims = 0;
2657  int *elem_dims = NULL;
2658  int *elem_lbs = NULL;
2659  bool firstone = true;
2660  bool havenulls = false;
2661  bool haveempty = false;
2662  char **subdata;
2663  bits8 **subbitmaps;
2664  int *subbytes;
2665  int *subnitems;
2666  int32 dataoffset;
2667  char *dat;
2668  int iitem;
2669 
2670  subdata = (char **) palloc(nelems * sizeof(char *));
2671  subbitmaps = (bits8 **) palloc(nelems * sizeof(bits8 *));
2672  subbytes = (int *) palloc(nelems * sizeof(int));
2673  subnitems = (int *) palloc(nelems * sizeof(int));
2674 
2675  /* loop through and get data area from each element */
2676  for (int elemoff = 0; elemoff < nelems; elemoff++)
2677  {
2678  Datum arraydatum;
2679  bool eisnull;
2680  ArrayType *array;
2681  int this_ndims;
2682 
2683  arraydatum = op->d.arrayexpr.elemvalues[elemoff];
2684  eisnull = op->d.arrayexpr.elemnulls[elemoff];
2685 
2686  /* temporarily ignore null subarrays */
2687  if (eisnull)
2688  {
2689  haveempty = true;
2690  continue;
2691  }
2692 
2693  array = DatumGetArrayTypeP(arraydatum);
2694 
2695  /* run-time double-check on element type */
2696  if (element_type != ARR_ELEMTYPE(array))
2697  ereport(ERROR,
2698  (errcode(ERRCODE_DATATYPE_MISMATCH),
2699  errmsg("cannot merge incompatible arrays"),
2700  errdetail("Array with element type %s cannot be "
2701  "included in ARRAY construct with element type %s.",
2702  format_type_be(ARR_ELEMTYPE(array)),
2703  format_type_be(element_type))));
2704 
2705  this_ndims = ARR_NDIM(array);
2706  /* temporarily ignore zero-dimensional subarrays */
2707  if (this_ndims <= 0)
2708  {
2709  haveempty = true;
2710  continue;
2711  }
2712 
2713  if (firstone)
2714  {
2715  /* Get sub-array details from first member */
2716  elem_ndims = this_ndims;
2717  ndims = elem_ndims + 1;
2718  if (ndims <= 0 || ndims > MAXDIM)
2719  ereport(ERROR,
2720  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
2721  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
2722  ndims, MAXDIM)));
2723 
2724  elem_dims = (int *) palloc(elem_ndims * sizeof(int));
2725  memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int));
2726  elem_lbs = (int *) palloc(elem_ndims * sizeof(int));
2727  memcpy(elem_lbs, ARR_LBOUND(array), elem_ndims * sizeof(int));
2728 
2729  firstone = false;
2730  }
2731  else
2732  {
2733  /* Check other sub-arrays are compatible */
2734  if (elem_ndims != this_ndims ||
2735  memcmp(elem_dims, ARR_DIMS(array),
2736  elem_ndims * sizeof(int)) != 0 ||
2737  memcmp(elem_lbs, ARR_LBOUND(array),
2738  elem_ndims * sizeof(int)) != 0)
2739  ereport(ERROR,
2740  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2741  errmsg("multidimensional arrays must have array "
2742  "expressions with matching dimensions")));
2743  }
2744 
2745  subdata[outer_nelems] = ARR_DATA_PTR(array);
2746  subbitmaps[outer_nelems] = ARR_NULLBITMAP(array);
2747  subbytes[outer_nelems] = ARR_SIZE(array) - ARR_DATA_OFFSET(array);
2748  nbytes += subbytes[outer_nelems];
2749  subnitems[outer_nelems] = ArrayGetNItems(this_ndims,
2750  ARR_DIMS(array));
2751  nitems += subnitems[outer_nelems];
2752  havenulls |= ARR_HASNULL(array);
2753  outer_nelems++;
2754  }
2755 
2756  /*
2757  * If all items were null or empty arrays, return an empty array;
2758  * otherwise, if some were and some weren't, raise error. (Note: we
2759  * must special-case this somehow to avoid trying to generate a 1-D
2760  * array formed from empty arrays. It's not ideal...)
2761  */
2762  if (haveempty)
2763  {
2764  if (ndims == 0) /* didn't find any nonempty array */
2765  {
2766  *op->resvalue = PointerGetDatum(construct_empty_array(element_type));
2767  return;
2768  }
2769  ereport(ERROR,
2770  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2771  errmsg("multidimensional arrays must have array "
2772  "expressions with matching dimensions")));
2773  }
2774 
2775  /* setup for multi-D array */
2776  dims[0] = outer_nelems;
2777  lbs[0] = 1;
2778  for (int i = 1; i < ndims; i++)
2779  {
2780  dims[i] = elem_dims[i - 1];
2781  lbs[i] = elem_lbs[i - 1];
2782  }
2783 
2784  if (havenulls)
2785  {
2786  dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
2787  nbytes += dataoffset;
2788  }
2789  else
2790  {
2791  dataoffset = 0; /* marker for no null bitmap */
2792  nbytes += ARR_OVERHEAD_NONULLS(ndims);
2793  }
2794 
2795  result = (ArrayType *) palloc(nbytes);
2796  SET_VARSIZE(result, nbytes);
2797  result->ndim = ndims;
2798  result->dataoffset = dataoffset;
2799  result->elemtype = element_type;
2800  memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
2801  memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
2802 
2803  dat = ARR_DATA_PTR(result);
2804  iitem = 0;
2805  for (int i = 0; i < outer_nelems; i++)
2806  {
2807  memcpy(dat, subdata[i], subbytes[i]);
2808  dat += subbytes[i];
2809  if (havenulls)
2810  array_bitmap_copy(ARR_NULLBITMAP(result), iitem,
2811  subbitmaps[i], 0,
2812  subnitems[i]);
2813  iitem += subnitems[i];
2814  }
2815  }
2816 
2817  *op->resvalue = PointerGetDatum(result);
2818 }
ExprEvalStep::arrayexpr
struct ExprEvalStep::@51::@70 arrayexpr
ARR_OVERHEAD_NONULLS
#define ARR_OVERHEAD_NONULLS(ndims)
Definition: array.h:298
ARR_SIZE
#define ARR_SIZE(a)
Definition: array.h:277
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
MAXDIM
#define MAXDIM
Definition: c.h:543
PointerGetDatum
#define PointerGetDatum(X)
Definition: postgres.h:556
array_bitmap_copy
void array_bitmap_copy(bits8 *destbitmap, int destoffset, const bits8 *srcbitmap, int srcoffset, int nitems)
Definition: arrayfuncs.c:4714
ArrayType::dataoffset
int32 dataoffset
Definition: array.h:84
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ArrayGetNItems
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:75
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
construct_empty_array
ArrayType * construct_empty_array(Oid elmtype)
Definition: arrayfuncs.c:3432
Oid
unsigned int Oid
Definition: postgres_ext.h:31
ARR_OVERHEAD_WITHNULLS
#define ARR_OVERHEAD_WITHNULLS(ndims, nitems)
Definition: array.h:300
int32
signed int int32
Definition: c.h:363
ARR_DATA_OFFSET
#define ARR_DATA_OFFSET(a)
Definition: array.h:304
ARR_LBOUND
#define ARR_LBOUND(a)
Definition: array.h:284
ERROR
#define ERROR
Definition: elog.h:43
ArrayType::elemtype
Oid elemtype
Definition: array.h:85
ARR_DIMS
#define ARR_DIMS(a)
Definition: array.h:282
ARR_DATA_PTR
#define ARR_DATA_PTR(a)
Definition: array.h:310
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:954
ARR_HASNULL
#define ARR_HASNULL(a)
Definition: array.h:279
ExprEvalStep::d
union ExprEvalStep::@51 d
bits8
uint8 bits8
Definition: c.h:382
Datum
uintptr_t Datum
Definition: postgres.h:367
ereport
#define ereport(elevel,...)
Definition: elog.h:144
ARR_NDIM
#define ARR_NDIM(a)
Definition: array.h:278
palloc
void * palloc(Size size)
Definition: mcxt.c:950
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821
i
int i
Definition: preproc-comment.c:23
SET_VARSIZE
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:329
construct_md_array
ArrayType * construct_md_array(Datum *elems, bool *nulls, int ndims, int *dims, int *lbs, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3348
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition: array.h:280
ARR_NULLBITMAP
#define ARR_NULLBITMAP(a)
Definition: array.h:288
ArrayType::ndim
int ndim
Definition: array.h:83
DatumGetArrayTypeP
#define DatumGetArrayTypeP(X)
Definition: array.h:249

◆ ExecEvalConstraintCheck()

void ExecEvalConstraintCheck ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3588 of file execExprInterp.c.

References ExprEvalStep::d, DatumGetBool, ExprEvalStep::domaincheck, ereport, errcode(), errdomainconstraint(), errmsg(), ERROR, and format_type_be().

Referenced by ExecInterpExpr().

3589 {
3590  if (!*op->d.domaincheck.checknull &&
3591  !DatumGetBool(*op->d.domaincheck.checkvalue))
3592  ereport(ERROR,
3593  (errcode(ERRCODE_CHECK_VIOLATION),
3594  errmsg("value for domain %s violates check constraint \"%s\"",
3595  format_type_be(op->d.domaincheck.resulttype),
3596  op->d.domaincheck.constraintname),
3597  errdomainconstraint(op->d.domaincheck.resulttype,
3598  op->d.domaincheck.constraintname)));
3599 }
ExprEvalStep::domaincheck
struct ExprEvalStep::@51::@80 domaincheck
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
ERROR
#define ERROR
Definition: elog.h:43
errdomainconstraint
int errdomainconstraint(Oid datatypeOid, const char *conname)
Definition: domains.c:384
DatumGetBool
#define DatumGetBool(X)
Definition: postgres.h:393
ExprEvalStep::d
union ExprEvalStep::@51 d
ereport
#define ereport(elevel,...)
Definition: elog.h:144
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821

◆ ExecEvalConstraintNotNull()

void ExecEvalConstraintNotNull ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3574 of file execExprInterp.c.

References ExprEvalStep::d, ExprEvalStep::domaincheck, ereport, errcode(), errdatatype(), errmsg(), ERROR, format_type_be(), and ExprEvalStep::resnull.

Referenced by ExecInterpExpr().

3575 {
3576  if (*op->resnull)
3577  ereport(ERROR,
3578  (errcode(ERRCODE_NOT_NULL_VIOLATION),
3579  errmsg("domain %s does not allow null values",
3580  format_type_be(op->d.domaincheck.resulttype)),
3581  errdatatype(op->d.domaincheck.resulttype)));
3582 }
ExprEvalStep::domaincheck
struct ExprEvalStep::@51::@80 domaincheck
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
ERROR
#define ERROR
Definition: elog.h:43
ExprEvalStep::d
union ExprEvalStep::@51 d
errdatatype
int errdatatype(Oid datatypeOid)
Definition: domains.c:360
ereport
#define ereport(elevel,...)
Definition: elog.h:144
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821

◆ ExecEvalConvertRowtype()

void ExecEvalConvertRowtype ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 3326 of file execExprInterp.c.

References ConvertRowtypeExpr::arg, Assert, convert(), ExprEvalStep::convert_rowtype, convert_tuples_by_name(), ExprEvalStep::d, DatumGetHeapTupleHeader, ExprContext::ecxt_per_query_memory, execute_attr_map_tuple(), exprType(), get_cached_rowtype(), heap_copy_tuple_as_datum(), HeapTupleGetDatum, HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, MemoryContextSwitchTo(), ExprEvalStep::resnull, ConvertRowtypeExpr::resulttype, ExprEvalStep::resvalue, HeapTupleData::t_data, HeapTupleData::t_len, and TupleDescData::tdtypeid.

Referenced by ExecInterpExpr().

3327 {
3328  ConvertRowtypeExpr *convert = op->d.convert_rowtype.convert;
3329  HeapTuple result;
3330  Datum tupDatum;
3331  HeapTupleHeader tuple;
3332  HeapTupleData tmptup;
3333  TupleDesc indesc,
3334  outdesc;
3335 
3336  /* NULL in -> NULL out */
3337  if (*op->resnull)
3338  return;
3339 
3340  tupDatum = *op->resvalue;
3341  tuple = DatumGetHeapTupleHeader(tupDatum);
3342 
3343  /* Lookup tupdescs if first time through or after rescan */
3344  if (op->d.convert_rowtype.indesc == NULL)
3345  {
3346  get_cached_rowtype(exprType((Node *) convert->arg), -1,
3347  &op->d.convert_rowtype.indesc,
3348  econtext);
3349  op->d.convert_rowtype.initialized = false;
3350  }
3351  if (op->d.convert_rowtype.outdesc == NULL)
3352  {
3353  get_cached_rowtype(convert->resulttype, -1,
3354  &op->d.convert_rowtype.outdesc,
3355  econtext);
3356  op->d.convert_rowtype.initialized = false;
3357  }
3358 
3359  indesc = op->d.convert_rowtype.indesc;
3360  outdesc = op->d.convert_rowtype.outdesc;
3361 
3362  /*
3363  * We used to be able to assert that incoming tuples are marked with
3364  * exactly the rowtype of indesc. However, now that ExecEvalWholeRowVar
3365  * might change the tuples' marking to plain RECORD due to inserting
3366  * aliases, we can only make this weak test:
3367  */
3368  Assert(HeapTupleHeaderGetTypeId(tuple) == indesc->tdtypeid ||
3369  HeapTupleHeaderGetTypeId(tuple) == RECORDOID);
3370 
3371  /* if first time through, initialize conversion map */
3372  if (!op->d.convert_rowtype.initialized)
3373  {
3374  MemoryContext old_cxt;
3375 
3376  /* allocate map in long-lived memory context */
3377  old_cxt = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
3378 
3379  /* prepare map from old to new attribute numbers */
3380  op->d.convert_rowtype.map = convert_tuples_by_name(indesc, outdesc);
3381  op->d.convert_rowtype.initialized = true;
3382 
3383  MemoryContextSwitchTo(old_cxt);
3384  }
3385 
3386  /* Following steps need a HeapTuple not a bare HeapTupleHeader */
3387  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
3388  tmptup.t_data = tuple;
3389 
3390  if (op->d.convert_rowtype.map != NULL)
3391  {
3392  /* Full conversion with attribute rearrangement needed */
3393  result = execute_attr_map_tuple(&tmptup, op->d.convert_rowtype.map);
3394  /* Result already has appropriate composite-datum header fields */
3395  *op->resvalue = HeapTupleGetDatum(result);
3396  }
3397  else
3398  {
3399  /*
3400  * The tuple is physically compatible as-is, but we need to insert the
3401  * destination rowtype OID in its composite-datum header field, so we
3402  * have to copy it anyway. heap_copy_tuple_as_datum() is convenient
3403  * for this since it will both make the physical copy and insert the
3404  * correct composite header fields. Note that we aren't expecting to
3405  * have to flatten any toasted fields: the input was a composite
3406  * datum, so it shouldn't contain any. So heap_copy_tuple_as_datum()
3407  * is overkill here, but its check for external fields is cheap.
3408  */
3409  *op->resvalue = heap_copy_tuple_as_datum(&tmptup, outdesc);
3410  }
3411 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::convert_rowtype
struct ExprEvalStep::@51::@81 convert_rowtype
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
Node
Definition: nodes.h:528
DatumGetHeapTupleHeader
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:294
HeapTupleData::t_data
HeapTupleHeader t_data
Definition: htup.h:68
convert
static void convert(const int32 val, char *const buf)
Definition: zic.c:1990
HeapTupleData::t_len
uint32 t_len
Definition: htup.h:64
convert_tuples_by_name
TupleConversionMap * convert_tuples_by_name(TupleDesc indesc, TupleDesc outdesc)
Definition: tupconvert.c:102
execute_attr_map_tuple
HeapTuple execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map)
Definition: tupconvert.c:139
heap_copy_tuple_as_datum
Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc)
Definition: heaptuple.c:984
ExprEvalStep::d
union ExprEvalStep::@51 d
get_cached_rowtype
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod, TupleDesc *cache_field, ExprContext *econtext)
Definition: execExprInterp.c:1945
Datum
uintptr_t Datum
Definition: postgres.h:367
HeapTupleHeaderGetTypeId
#define HeapTupleHeaderGetTypeId(tup)
Definition: htup_details.h:458
Assert
#define Assert(condition)
Definition: c.h:746
exprType
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
HeapTupleGetDatum
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221
ExprContext::ecxt_per_query_memory
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:232
TupleDescData::tdtypeid
Oid tdtypeid
Definition: tupdesc.h:82
HeapTupleHeaderGetDatumLength
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecEvalCurrentOfExpr()

void ExecEvalCurrentOfExpr ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 2481 of file execExprInterp.c.

References ereport, errcode(), errmsg(), and ERROR.

Referenced by ExecInterpExpr().

2482 {
2483  ereport(ERROR,
2484  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2485  errmsg("WHERE CURRENT OF is not supported for this table type")));
2486 }
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
ERROR
#define ERROR
Definition: elog.h:43
ereport
#define ereport(elevel,...)
Definition: elog.h:144
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821

◆ ExecEvalFieldSelect()

void ExecEvalFieldSelect ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2940 of file execExprInterp.c.

References Assert, ExprEvalStep::d, DatumGetEOHP(), DatumGetHeapTupleHeader, DatumGetPointer, elog, ER_MAGIC, ExpandedRecordHeader::er_magic, ereport, errcode(), errdetail(), errmsg(), ERROR, expanded_record_get_field(), expanded_record_get_tupdesc(), ExprEvalStep::fieldselect, format_type_be(), get_cached_rowtype(), heap_getattr, HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, TupleDescData::natts, ExprEvalStep::resnull, ExprEvalStep::resvalue, HeapTupleData::t_data, HeapTupleData::t_len, TupleDescAttr, and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by ExecInterpExpr().

2941 {
2942  AttrNumber fieldnum = op->d.fieldselect.fieldnum;
2943  Datum tupDatum;
2944  HeapTupleHeader tuple;
2945  Oid tupType;
2946  int32 tupTypmod;
2947  TupleDesc tupDesc;
2948  Form_pg_attribute attr;
2949  HeapTupleData tmptup;
2950 
2951  /* NULL record -> NULL result */
2952  if (*op->resnull)
2953  return;
2954 
2955  tupDatum = *op->resvalue;
2956 
2957  /* We can special-case expanded records for speed */
2958  if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(tupDatum)))
2959  {
2960  ExpandedRecordHeader *erh = (ExpandedRecordHeader *) DatumGetEOHP(tupDatum);
2961 
2962  Assert(erh->er_magic == ER_MAGIC);
2963 
2964  /* Extract record's TupleDesc */
2965  tupDesc = expanded_record_get_tupdesc(erh);
2966 
2967  /*
2968  * Find field's attr record. Note we don't support system columns
2969  * here: a datum tuple doesn't have valid values for most of the
2970  * interesting system columns anyway.
2971  */
2972  if (fieldnum <= 0) /* should never happen */
2973  elog(ERROR, "unsupported reference to system column %d in FieldSelect",
2974  fieldnum);
2975  if (fieldnum > tupDesc->natts) /* should never happen */
2976  elog(ERROR, "attribute number %d exceeds number of columns %d",
2977  fieldnum, tupDesc->natts);
2978  attr = TupleDescAttr(tupDesc, fieldnum - 1);
2979 
2980  /* Check for dropped column, and force a NULL result if so */
2981  if (attr->attisdropped)
2982  {
2983  *op->resnull = true;
2984  return;
2985  }
2986 
2987  /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
2988  /* As in CheckVarSlotCompatibility, we should but can't check typmod */
2989  if (op->d.fieldselect.resulttype != attr->atttypid)
2990  ereport(ERROR,
2991  (errcode(ERRCODE_DATATYPE_MISMATCH),
2992  errmsg("attribute %d has wrong type", fieldnum),
2993  errdetail("Table has type %s, but query expects %s.",
2994  format_type_be(attr->atttypid),
2995  format_type_be(op->d.fieldselect.resulttype))));
2996 
2997  /* extract the field */
2998  *op->resvalue = expanded_record_get_field(erh, fieldnum,
2999  op->resnull);
3000  }
3001  else
3002  {
3003  /* Get the composite datum and extract its type fields */
3004  tuple = DatumGetHeapTupleHeader(tupDatum);
3005 
3006  tupType = HeapTupleHeaderGetTypeId(tuple);
3007  tupTypmod = HeapTupleHeaderGetTypMod(tuple);
3008 
3009  /* Lookup tupdesc if first time through or if type changes */
3010  tupDesc = get_cached_rowtype(tupType, tupTypmod,
3011  &op->d.fieldselect.argdesc,
3012  econtext);
3013 
3014  /*
3015  * Find field's attr record. Note we don't support system columns
3016  * here: a datum tuple doesn't have valid values for most of the
3017  * interesting system columns anyway.
3018  */
3019  if (fieldnum <= 0) /* should never happen */
3020  elog(ERROR, "unsupported reference to system column %d in FieldSelect",
3021  fieldnum);
3022  if (fieldnum > tupDesc->natts) /* should never happen */
3023  elog(ERROR, "attribute number %d exceeds number of columns %d",
3024  fieldnum, tupDesc->natts);
3025  attr = TupleDescAttr(tupDesc, fieldnum - 1);
3026 
3027  /* Check for dropped column, and force a NULL result if so */
3028  if (attr->attisdropped)
3029  {
3030  *op->resnull = true;
3031  return;
3032  }
3033 
3034  /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
3035  /* As in CheckVarSlotCompatibility, we should but can't check typmod */
3036  if (op->d.fieldselect.resulttype != attr->atttypid)
3037  ereport(ERROR,
3038  (errcode(ERRCODE_DATATYPE_MISMATCH),
3039  errmsg("attribute %d has wrong type", fieldnum),
3040  errdetail("Table has type %s, but query expects %s.",
3041  format_type_be(attr->atttypid),
3042  format_type_be(op->d.fieldselect.resulttype))));
3043 
3044  /* heap_getattr needs a HeapTuple not a bare HeapTupleHeader */
3045  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
3046  tmptup.t_data = tuple;
3047 
3048  /* extract the field */
3049  *op->resvalue = heap_getattr(&tmptup,
3050  fieldnum,
3051  tupDesc,
3052  op->resnull);
3053  }
3054 }
VARATT_IS_EXTERNAL_EXPANDED
#define VARATT_IS_EXTERNAL_EXPANDED(PTR)
Definition: postgres.h:322
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
expanded_record_get_field
static Datum expanded_record_get_field(ExpandedRecordHeader *erh, int fnumber, bool *isnull)
Definition: expandedrecord.h:218
TupleDescAttr
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
Oid
unsigned int Oid
Definition: postgres_ext.h:31
DatumGetHeapTupleHeader
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:294
int32
signed int int32
Definition: c.h:363
HeapTupleData::t_data
HeapTupleHeader t_data
Definition: htup.h:68
HeapTupleHeaderGetTypMod
#define HeapTupleHeaderGetTypMod(tup)
Definition: htup_details.h:468
ERROR
#define ERROR
Definition: elog.h:43
HeapTupleData::t_len
uint32 t_len
Definition: htup.h:64
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:954
Form_pg_attribute
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
ExprEvalStep::fieldselect
struct ExprEvalStep::@51::@76 fieldselect
expanded_record_get_tupdesc
static TupleDesc expanded_record_get_tupdesc(ExpandedRecordHeader *erh)
Definition: expandedrecord.h:208
ExprEvalStep::d
union ExprEvalStep::@51 d
DatumGetEOHP
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
heap_getattr
#define heap_getattr(tup, attnum, tupleDesc, isnull)
Definition: htup_details.h:762
get_cached_rowtype
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod, TupleDesc *cache_field, ExprContext *econtext)
Definition: execExprInterp.c:1945
Datum
uintptr_t Datum
Definition: postgres.h:367
ER_MAGIC
#define ER_MAGIC
Definition: expandedrecord.h:40
HeapTupleHeaderGetTypeId
#define HeapTupleHeaderGetTypeId(tup)
Definition: htup_details.h:458
ereport
#define ereport(elevel,...)
Definition: elog.h:144
Assert
#define Assert(condition)
Definition: c.h:746
DatumGetPointer
#define DatumGetPointer(X)
Definition: postgres.h:549
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821
elog
#define elog(elevel,...)
Definition: elog.h:214
AttrNumber
int16 AttrNumber
Definition: attnum.h:21
HeapTupleHeaderGetDatumLength
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecEvalFieldStoreDeForm()

void ExecEvalFieldStoreDeForm ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 3066 of file execExprInterp.c.

References ExprEvalStep::d, DatumGetHeapTupleHeader, elog, ERROR, ExprEvalStep::fieldstore, get_cached_rowtype(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength, InvalidOid, ItemPointerSetInvalid, TupleDescData::natts, ExprEvalStep::resnull, ExprEvalStep::resvalue, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, and unlikely.

Referenced by ExecInterpExpr().

3067 {
3068  TupleDesc tupDesc;
3069 
3070  /* Lookup tupdesc if first time through or after rescan */
3071  tupDesc = get_cached_rowtype(op->d.fieldstore.fstore->resulttype, -1,
3072  op->d.fieldstore.argdesc, econtext);
3073 
3074  /* Check that current tupdesc doesn't have more fields than we allocated */
3075  if (unlikely(tupDesc->natts > op->d.fieldstore.ncolumns))
3076  elog(ERROR, "too many columns in composite type %u",
3077  op->d.fieldstore.fstore->resulttype);
3078 
3079  if (*op->resnull)
3080  {
3081  /* Convert null input tuple into an all-nulls row */
3082  memset(op->d.fieldstore.nulls, true,
3083  op->d.fieldstore.ncolumns * sizeof(bool));
3084  }
3085  else
3086  {
3087  /*
3088  * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader. We
3089  * set all the fields in the struct just in case.
3090  */
3091  Datum tupDatum = *op->resvalue;
3092  HeapTupleHeader tuphdr;
3093  HeapTupleData tmptup;
3094 
3095  tuphdr = DatumGetHeapTupleHeader(tupDatum);
3096  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
3097  ItemPointerSetInvalid(&(tmptup.t_self));
3098  tmptup.t_tableOid = InvalidOid;
3099  tmptup.t_data = tuphdr;
3100 
3101  heap_deform_tuple(&tmptup, tupDesc,
3102  op->d.fieldstore.values,
3103  op->d.fieldstore.nulls);
3104  }
3105 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ExprEvalStep::fieldstore
struct ExprEvalStep::@51::@77 fieldstore
DatumGetHeapTupleHeader
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:294
HeapTupleData::t_data
HeapTupleHeader t_data
Definition: htup.h:68
ERROR
#define ERROR
Definition: elog.h:43
HeapTupleData::t_self
ItemPointerData t_self
Definition: htup.h:65
HeapTupleData::t_len
uint32 t_len
Definition: htup.h:64
HeapTupleData::t_tableOid
Oid t_tableOid
Definition: htup.h:66
ExprEvalStep::d
union ExprEvalStep::@51 d
get_cached_rowtype
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod, TupleDesc *cache_field, ExprContext *econtext)
Definition: execExprInterp.c:1945
Datum
uintptr_t Datum
Definition: postgres.h:367
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:36
heap_deform_tuple
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
ItemPointerSetInvalid
#define ItemPointerSetInvalid(pointer)
Definition: itemptr.h:172
elog
#define elog(elevel,...)
Definition: elog.h:214
unlikely
#define unlikely(x)
Definition: c.h:207
HeapTupleHeaderGetDatumLength
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecEvalFieldStoreForm()

void ExecEvalFieldStoreForm ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 3112 of file execExprInterp.c.

References ExprEvalStep::d, ExprEvalStep::fieldstore, heap_form_tuple(), HeapTupleGetDatum, ExprEvalStep::resnull, and ExprEvalStep::resvalue.

Referenced by ExecInterpExpr().

3113 {
3114  HeapTuple tuple;
3115 
3116  /* argdesc should already be valid from the DeForm step */
3117  tuple = heap_form_tuple(*op->d.fieldstore.argdesc,
3118  op->d.fieldstore.values,
3119  op->d.fieldstore.nulls);
3120 
3121  *op->resvalue = HeapTupleGetDatum(tuple);
3122  *op->resnull = false;
3123 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ExprEvalStep::fieldstore
struct ExprEvalStep::@51::@77 fieldstore
heap_form_tuple
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
ExprEvalStep::d
union ExprEvalStep::@51 d
HeapTupleGetDatum
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221

◆ ExecEvalFuncExprFusage()

void ExecEvalFuncExprFusage ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2292 of file execExprInterp.c.

References ExprEvalStep::d, ExprEvalStep::func, FunctionCallInfoBaseData::isnull, pgstat_end_function_usage(), pgstat_init_function_usage(), ExprEvalStep::resnull, and ExprEvalStep::resvalue.

Referenced by ExecInterpExpr().

2294 {
2295  FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
2296  PgStat_FunctionCallUsage fcusage;
2297  Datum d;
2298 
2299  pgstat_init_function_usage(fcinfo, &fcusage);
2300 
2301  fcinfo->isnull = false;
2302  d = op->d.func.fn_addr(fcinfo);
2303  *op->resvalue = d;
2304  *op->resnull = fcinfo->isnull;
2305 
2306  pgstat_end_function_usage(&fcusage, true);
2307 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ExprEvalStep::func
struct ExprEvalStep::@51::@58 func
pgstat_init_function_usage
void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
Definition: pgstat.c:1786
ExprEvalStep::d
union ExprEvalStep::@51 d
Datum
uintptr_t Datum
Definition: postgres.h:367
pgstat_end_function_usage
void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
Definition: pgstat.c:1858
PgStat_FunctionCallUsage
Definition: pgstat.h:1302

◆ ExecEvalFuncExprStrictFusage()

void ExecEvalFuncExprStrictFusage ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2313 of file execExprInterp.c.

References FunctionCallInfoBaseData::args, generate_unaccent_rules::args, ExprEvalStep::d, ExprEvalStep::func, FunctionCallInfoBaseData::isnull, pgstat_end_function_usage(), pgstat_init_function_usage(), ExprEvalStep::resnull, and ExprEvalStep::resvalue.

Referenced by ExecInterpExpr().

2315 {
2316 
2317  FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
2318  PgStat_FunctionCallUsage fcusage;
2319  NullableDatum *args = fcinfo->args;
2320  int nargs = op->d.func.nargs;
2321  Datum d;
2322 
2323  /* strict function, so check for NULL args */
2324  for (int argno = 0; argno < nargs; argno++)
2325  {
2326  if (args[argno].isnull)
2327  {
2328  *op->resnull = true;
2329  return;
2330  }
2331  }
2332 
2333  pgstat_init_function_usage(fcinfo, &fcusage);
2334 
2335  fcinfo->isnull = false;
2336  d = op->d.func.fn_addr(fcinfo);
2337  *op->resvalue = d;
2338  *op->resnull = fcinfo->isnull;
2339 
2340  pgstat_end_function_usage(&fcusage, true);
2341 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ExprEvalStep::func
struct ExprEvalStep::@51::@58 func
pgstat_init_function_usage
void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
Definition: pgstat.c:1786
FunctionCallInfoBaseData::args
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:285
ExprEvalStep::d
union ExprEvalStep::@51 d
Datum
uintptr_t Datum
Definition: postgres.h:367
pgstat_end_function_usage
void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
Definition: pgstat.c:1858
PgStat_FunctionCallUsage
Definition: pgstat.h:1302

◆ ExecEvalGroupingFunc()

void ExecEvalGroupingFunc ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3827 of file execExprInterp.c.

References attnum, bms_is_member(), castNode, ExprEvalStep::d, AggState::grouped_cols, ExprEvalStep::grouping_func, Int32GetDatum, lfirst_int, ExprState::parent, ExprEvalStep::resnull, and ExprEvalStep::resvalue.

Referenced by ExecInterpExpr().

3828 {
3829  AggState *aggstate = castNode(AggState, state->parent);
3830  int result = 0;
3831  Bitmapset *grouped_cols = aggstate->grouped_cols;
3832  ListCell *lc;
3833 
3834  foreach(lc, op->d.grouping_func.clauses)
3835  {
3836  int attnum = lfirst_int(lc);
3837 
3838  result <<= 1;
3839 
3840  if (!bms_is_member(attnum, grouped_cols))
3841  result |= 1;
3842  }
3843 
3844  *op->resvalue = Int32GetDatum(result);
3845  *op->resnull = false;
3846 }
ExprState::parent
struct PlanState * parent
Definition: execnodes.h:107
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
castNode
#define castNode(_type_, nodeptr)
Definition: nodes.h:597
ExprEvalStep::grouping_func
struct ExprEvalStep::@51::@85 grouping_func
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
lfirst_int
#define lfirst_int(lc)
Definition: pg_list.h:170
AggState::grouped_cols
Bitmapset * grouped_cols
Definition: execnodes.h:2167
ExprEvalStep::d
union ExprEvalStep::@51 d
attnum
int16 attnum
Definition: pg_attribute.h:79
Int32GetDatum
#define Int32GetDatum(X)
Definition: postgres.h:479
bms_is_member
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:427

◆ ExecEvalMinMax()

void ExecEvalMinMax ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 2887 of file execExprInterp.c.

References FunctionCallInfoBaseData::args, Assert, ExprEvalStep::d, DatumGetInt32, FunctionCallInvoke, IS_GREATEST, IS_LEAST, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, ExprEvalStep::minmax, ExprEvalStep::resnull, ExprEvalStep::resvalue, NullableDatum::value, and values.

Referenced by ExecInterpExpr().

2888 {
2889  Datum *values = op->d.minmax.values;
2890  bool *nulls = op->d.minmax.nulls;
2891  FunctionCallInfo fcinfo = op->d.minmax.fcinfo_data;
2892  MinMaxOp operator = op->d.minmax.op;
2893 
2894  /* set at initialization */
2895  Assert(fcinfo->args[0].isnull == false);
2896  Assert(fcinfo->args[1].isnull == false);
2897 
2898  /* default to null result */
2899  *op->resnull = true;
2900 
2901  for (int off = 0; off < op->d.minmax.nelems; off++)
2902  {
2903  /* ignore NULL inputs */
2904  if (nulls[off])
2905  continue;
2906 
2907  if (*op->resnull)
2908  {
2909  /* first nonnull input, adopt value */
2910  *op->resvalue = values[off];
2911  *op->resnull = false;
2912  }
2913  else
2914  {
2915  int cmpresult;
2916 
2917  /* apply comparison function */
2918  fcinfo->args[0].value = *op->resvalue;
2919  fcinfo->args[1].value = values[off];
2920 
2921  fcinfo->isnull = false;
2922  cmpresult = DatumGetInt32(FunctionCallInvoke(fcinfo));
2923  if (fcinfo->isnull) /* probably should not happen */
2924  continue;
2925 
2926  if (cmpresult > 0 && operator == IS_LEAST)
2927  *op->resvalue = values[off];
2928  else if (cmpresult < 0 && operator == IS_GREATEST)
2929  *op->resvalue = values[off];
2930  }
2931  }
2932 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
DatumGetInt32
#define DatumGetInt32(X)
Definition: postgres.h:472
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
MinMaxOp
MinMaxOp
Definition: primnodes.h:1096
FunctionCallInfoBaseData::args
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
FunctionCallInvoke
#define FunctionCallInvoke(fcinfo)
Definition: fmgr.h:172
NullableDatum::value
Datum value
Definition: postgres.h:378
ExprEvalStep::d
union ExprEvalStep::@51 d
Datum
uintptr_t Datum
Definition: postgres.h:367
Assert
#define Assert(condition)
Definition: c.h:746
values
static Datum values[MAXATTR]
Definition: bootstrap.c:165
ExprEvalStep::minmax
struct ExprEvalStep::@51::@75 minmax

◆ ExecEvalNextValueExpr()

void ExecEvalNextValueExpr ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 2492 of file execExprInterp.c.

References ExprEvalStep::d, elog, ERROR, Int16GetDatum, Int32GetDatum, Int64GetDatum(), newval, nextval_internal(), ExprEvalStep::nextvalueexpr, ExprEvalStep::resnull, and ExprEvalStep::resvalue.

Referenced by ExecInterpExpr().

2493 {
2494  int64 newval = nextval_internal(op->d.nextvalueexpr.seqid, false);
2495 
2496  switch (op->d.nextvalueexpr.seqtypid)
2497  {
2498  case INT2OID:
2499  *op->resvalue = Int16GetDatum((int16) newval);
2500  break;
2501  case INT4OID:
2502  *op->resvalue = Int32GetDatum((int32) newval);
2503  break;
2504  case INT8OID:
2505  *op->resvalue = Int64GetDatum((int64) newval);
2506  break;
2507  default:
2508  elog(ERROR, "unsupported sequence type %u",
2509  op->d.nextvalueexpr.seqtypid);
2510  }
2511  *op->resnull = false;
2512 }
int16
signed short int16
Definition: c.h:362
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
nextval_internal
int64 nextval_internal(Oid relid, bool check_permissions)
Definition: sequence.c:579
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
Int16GetDatum
#define Int16GetDatum(X)
Definition: postgres.h:451
int32
signed int int32
Definition: c.h:363
ERROR
#define ERROR
Definition: elog.h:43
Int64GetDatum
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1701
ExprEvalStep::d
union ExprEvalStep::@51 d
ExprEvalStep::nextvalueexpr
struct ExprEvalStep::@51::@69 nextvalueexpr
newval
#define newval
Int32GetDatum
#define Int32GetDatum(X)
Definition: postgres.h:479
elog
#define elog(elevel,...)
Definition: elog.h:214

◆ ExecEvalParamExec()

void ExecEvalParamExec ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2350 of file execExprInterp.c.

References Assert, ExprEvalStep::d, ExprContext::ecxt_param_exec_vals, ParamExecData::execPlan, ExecSetParamPlan(), ParamExecData::isnull, ExprEvalStep::param, ExprEvalStep::resnull, ExprEvalStep::resvalue, unlikely, and ParamExecData::value.

Referenced by ExecInterpExpr().

2351 {
2352  ParamExecData *prm;
2353 
2354  prm = &(econtext->ecxt_param_exec_vals[op->d.param.paramid]);
2355  if (unlikely(prm->execPlan != NULL))
2356  {
2357  /* Parameter not evaluated yet, so go do it */
2358  ExecSetParamPlan(prm->execPlan, econtext);
2359  /* ExecSetParamPlan should have processed this param... */
2360  Assert(prm->execPlan == NULL);
2361  }
2362  *op->resvalue = prm->value;
2363  *op->resnull = prm->isnull;
2364 }
ExprEvalStep::param
struct ExprEvalStep::@51::@63 param
ParamExecData::execPlan
void * execPlan
Definition: params.h:148
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ExecSetParamPlan
void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
Definition: nodeSubplan.c:1050
ParamExecData::isnull
bool isnull
Definition: params.h:150
ExprContext::ecxt_param_exec_vals
ParamExecData * ecxt_param_exec_vals
Definition: execnodes.h:236
ExprEvalStep::d
union ExprEvalStep::@51 d
Assert
#define Assert(condition)
Definition: c.h:746
ParamExecData::value
Datum value
Definition: params.h:149
unlikely
#define unlikely(x)
Definition: c.h:207

◆ ExecEvalParamExtern()

void ExecEvalParamExtern ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2372 of file execExprInterp.c.

References ExprEvalStep::d, ExprContext::ecxt_param_list_info, ereport, errcode(), errmsg(), ERROR, format_type_be(), ParamExternData::isnull, likely, OidIsValid, ExprEvalStep::param, ParamListInfoData::paramFetch, ParamListInfoData::params, ParamExternData::ptype, ExprEvalStep::resnull, ExprEvalStep::resvalue, unlikely, and ParamExternData::value.

Referenced by ExecInterpExpr().

2373 {
2374  ParamListInfo paramInfo = econtext->ecxt_param_list_info;
2375  int paramId = op->d.param.paramid;
2376 
2377  if (likely(paramInfo &&
2378  paramId > 0 && paramId <= paramInfo->numParams))
2379  {
2380  ParamExternData *prm;
2381  ParamExternData prmdata;
2382 
2383  /* give hook a chance in case parameter is dynamic */
2384  if (paramInfo->paramFetch != NULL)
2385  prm = paramInfo->paramFetch(paramInfo, paramId, false, &prmdata);
2386  else
2387  prm = &paramInfo->params[paramId - 1];
2388 
2389  if (likely(OidIsValid(prm->ptype)))
2390  {
2391  /* safety check in case hook did something unexpected */
2392  if (unlikely(prm->ptype != op->d.param.paramtype))
2393  ereport(ERROR,
2394  (errcode(ERRCODE_DATATYPE_MISMATCH),
2395  errmsg("type of parameter %d (%s) does not match that when preparing the plan (%s)",
2396  paramId,
2397  format_type_be(prm->ptype),
2398  format_type_be(op->d.param.paramtype))));
2399  *op->resvalue = prm->value;
2400  *op->resnull = prm->isnull;
2401  return;
2402  }
2403  }
2404 
2405  ereport(ERROR,
2406  (errcode(ERRCODE_UNDEFINED_OBJECT),
2407  errmsg("no value found for parameter %d", paramId)));
2408 }
ExprEvalStep::param
struct ExprEvalStep::@51::@63 param
ParamListInfoData::params
ParamExternData params[FLEXIBLE_ARRAY_MEMBER]
Definition: params.h:125
ParamExternData::value
Datum value
Definition: params.h:92
likely
#define likely(x)
Definition: c.h:206
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:652
ParamListInfoData::paramFetch
ParamFetchHook paramFetch
Definition: params.h:112
ERROR
#define ERROR
Definition: elog.h:43
ExprEvalStep::d
union ExprEvalStep::@51 d
ereport
#define ereport(elevel,...)
Definition: elog.h:144
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821
unlikely
#define unlikely(x)
Definition: c.h:207
ExprContext::ecxt_param_list_info
ParamListInfo ecxt_param_list_info
Definition: execnodes.h:237
ParamExternData::isnull
bool isnull
Definition: params.h:93

◆ ExecEvalRow()

void ExecEvalRow ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 2867 of file execExprInterp.c.

References ExprEvalStep::d, heap_form_tuple(), HeapTupleGetDatum, ExprEvalStep::resnull, ExprEvalStep::resvalue, and ExprEvalStep::row.

Referenced by ExecInterpExpr().

2868 {
2869  HeapTuple tuple;
2870 
2871  /* build tuple from evaluated field values */
2872  tuple = heap_form_tuple(op->d.row.tupdesc,
2873  op->d.row.elemvalues,
2874  op->d.row.elemnulls);
2875 
2876  *op->resvalue = HeapTupleGetDatum(tuple);
2877  *op->resnull = false;
2878 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
heap_form_tuple
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
ExprEvalStep::row
struct ExprEvalStep::@51::@72 row
ExprEvalStep::d
union ExprEvalStep::@51 d
HeapTupleGetDatum
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221

◆ ExecEvalRowNotNull()

void ExecEvalRowNotNull ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2527 of file execExprInterp.c.

References ExecEvalRowNullInt().

Referenced by ExecInterpExpr().

2528 {
2529  ExecEvalRowNullInt(state, op, econtext, false);
2530 }
ExecEvalRowNullInt
static void ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op, ExprContext *econtext, bool checkisnull)
Definition: execExprInterp.c:2534

◆ ExecEvalRowNull()

void ExecEvalRowNull ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 2518 of file execExprInterp.c.

References ExecEvalRowNullInt().

Referenced by ExecInterpExpr().

2519 {
2520  ExecEvalRowNullInt(state, op, econtext, true);
2521 }
ExecEvalRowNullInt
static void ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op, ExprContext *econtext, bool checkisnull)
Definition: execExprInterp.c:2534

◆ ExecEvalScalarArrayOp()

void ExecEvalScalarArrayOp ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3424 of file execExprInterp.c.

References FunctionCallInfoBaseData::args, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), att_addlength_pointer, att_align_nominal, BoolGetDatum, ExprEvalStep::d, DatumGetArrayTypeP, DatumGetBool, fetch_att, get_typlenbyvalalign(), i, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::scalararrayop, typalign, and NullableDatum::value.

Referenced by ExecInterpExpr().

3425 {
3426  FunctionCallInfo fcinfo = op->d.scalararrayop.fcinfo_data;
3427  bool useOr = op->d.scalararrayop.useOr;
3428  bool strictfunc = op->d.scalararrayop.finfo->fn_strict;
3429  ArrayType *arr;
3430  int nitems;
3431  Datum result;
3432  bool resultnull;
3433  int16 typlen;
3434  bool typbyval;
3435  char typalign;
3436  char *s;
3437  bits8 *bitmap;
3438  int bitmask;
3439 
3440  /*
3441  * If the array is NULL then we return NULL --- it's not very meaningful
3442  * to do anything else, even if the operator isn't strict.
3443  */
3444  if (*op->resnull)
3445  return;
3446 
3447  /* Else okay to fetch and detoast the array */
3448  arr = DatumGetArrayTypeP(*op->resvalue);
3449 
3450  /*
3451  * If the array is empty, we return either FALSE or TRUE per the useOr
3452  * flag. This is correct even if the scalar is NULL; since we would
3453  * evaluate the operator zero times, it matters not whether it would want
3454  * to return NULL.
3455  */
3456  nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
3457  if (nitems <= 0)
3458  {
3459  *op->resvalue = BoolGetDatum(!useOr);
3460  *op->resnull = false;
3461  return;
3462  }
3463 
3464  /*
3465  * If the scalar is NULL, and the function is strict, return NULL; no
3466  * point in iterating the loop.
3467  */
3468  if (fcinfo->args[0].isnull && strictfunc)
3469  {
3470  *op->resnull = true;
3471  return;
3472  }
3473 
3474  /*
3475  * We arrange to look up info about the element type only once per series
3476  * of calls, assuming the element type doesn't change underneath us.
3477  */
3478  if (op->d.scalararrayop.element_type != ARR_ELEMTYPE(arr))
3479  {
3480  get_typlenbyvalalign(ARR_ELEMTYPE(arr),
3481  &op->d.scalararrayop.typlen,
3482  &op->d.scalararrayop.typbyval,
3483  &op->d.scalararrayop.typalign);
3484  op->d.scalararrayop.element_type = ARR_ELEMTYPE(arr);
3485  }
3486 
3487  typlen = op->d.scalararrayop.typlen;
3488  typbyval = op->d.scalararrayop.typbyval;
3489  typalign = op->d.scalararrayop.typalign;
3490 
3491  /* Initialize result appropriately depending on useOr */
3492  result = BoolGetDatum(!useOr);
3493  resultnull = false;
3494 
3495  /* Loop over the array elements */
3496  s = (char *) ARR_DATA_PTR(arr);
3497  bitmap = ARR_NULLBITMAP(arr);
3498  bitmask = 1;
3499 
3500  for (int i = 0; i < nitems; i++)
3501  {
3502  Datum elt;
3503  Datum thisresult;
3504 
3505  /* Get array element, checking for NULL */
3506  if (bitmap && (*bitmap & bitmask) == 0)
3507  {
3508  fcinfo->args[1].value = (Datum) 0;
3509  fcinfo->args[1].isnull = true;
3510  }
3511  else
3512  {
3513  elt = fetch_att(s, typbyval, typlen);
3514  s = att_addlength_pointer(s, typlen, s);
3515  s = (char *) att_align_nominal(s, typalign);
3516  fcinfo->args[1].value = elt;
3517  fcinfo->args[1].isnull = false;
3518  }
3519 
3520  /* Call comparison function */
3521  if (fcinfo->args[1].isnull && strictfunc)
3522  {
3523  fcinfo->isnull = true;
3524  thisresult = (Datum) 0;
3525  }
3526  else
3527  {
3528  fcinfo->isnull = false;
3529  thisresult = op->d.scalararrayop.fn_addr(fcinfo);
3530  }
3531 
3532  /* Combine results per OR or AND semantics */
3533  if (fcinfo->isnull)
3534  resultnull = true;
3535  else if (useOr)
3536  {
3537  if (DatumGetBool(thisresult))
3538  {
3539  result = BoolGetDatum(true);
3540  resultnull = false;
3541  break; /* needn't look at any more elements */
3542  }
3543  }
3544  else
3545  {
3546  if (!DatumGetBool(thisresult))
3547  {
3548  result = BoolGetDatum(false);
3549  resultnull = false;
3550  break; /* needn't look at any more elements */
3551  }
3552  }
3553 
3554  /* advance bitmap pointer if any */
3555  if (bitmap)
3556  {
3557  bitmask <<= 1;
3558  if (bitmask == 0x100)
3559  {
3560  bitmap++;
3561  bitmask = 1;
3562  }
3563  }
3564  }
3565 
3566  *op->resvalue = result;
3567  *op->resnull = resultnull;
3568 }
int16
signed short int16
Definition: c.h:362
att_align_nominal
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:148
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
get_typlenbyvalalign
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2159
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ArrayGetNItems
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:75
ExprEvalStep::scalararrayop
struct ExprEvalStep::@51::@82 scalararrayop
typalign
char typalign
Definition: pg_type.h:170
FunctionCallInfoBaseData::args
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
ARR_DIMS
#define ARR_DIMS(a)
Definition: array.h:282
ARR_DATA_PTR
#define ARR_DATA_PTR(a)
Definition: array.h:310
DatumGetBool
#define DatumGetBool(X)
Definition: postgres.h:393
att_addlength_pointer
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:176
NullableDatum::value
Datum value
Definition: postgres.h:378
ExprEvalStep::d
union ExprEvalStep::@51 d
bits8
uint8 bits8
Definition: c.h:382
Datum
uintptr_t Datum
Definition: postgres.h:367
BoolGetDatum
#define BoolGetDatum(X)
Definition: postgres.h:402
ARR_NDIM
#define ARR_NDIM(a)
Definition: array.h:278
fetch_att
#define fetch_att(T, attbyval, attlen)
Definition: tupmacs.h:75
i
int i
Definition: preproc-comment.c:23
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition: array.h:280
ARR_NULLBITMAP
#define ARR_NULLBITMAP(a)
Definition: array.h:288
DatumGetArrayTypeP
#define DatumGetArrayTypeP(X)
Definition: array.h:249

◆ ExecEvalSQLValueFunction()

void ExecEvalSQLValueFunction ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 2414 of file execExprInterp.c.

References current_database(), current_schema(), current_user(), ExprEvalStep::d, DateADTGetDatum, GetSQLCurrentDate(), GetSQLCurrentTime(), GetSQLCurrentTimestamp(), GetSQLLocalTime(), GetSQLLocalTimestamp(), InitFunctionCallInfoData, InvalidOid, LOCAL_FCINFO, SQLValueFunction::op, ExprEvalStep::resnull, ExprEvalStep::resvalue, session_user(), ExprEvalStep::sqlvaluefunction, SVFOP_CURRENT_CATALOG, SVFOP_CURRENT_DATE, SVFOP_CURRENT_ROLE, SVFOP_CURRENT_SCHEMA, SVFOP_CURRENT_TIME, SVFOP_CURRENT_TIME_N, SVFOP_CURRENT_TIMESTAMP, SVFOP_CURRENT_TIMESTAMP_N, SVFOP_CURRENT_USER, SVFOP_LOCALTIME, SVFOP_LOCALTIME_N, SVFOP_LOCALTIMESTAMP, SVFOP_LOCALTIMESTAMP_N, SVFOP_SESSION_USER, SVFOP_USER, TimeADTGetDatum, TimestampGetDatum, TimestampTzGetDatum, TimeTzADTPGetDatum, and SQLValueFunction::typmod.

Referenced by ExecInterpExpr().

2415 {
2416  LOCAL_FCINFO(fcinfo, 0);
2417  SQLValueFunction *svf = op->d.sqlvaluefunction.svf;
2418 
2419  *op->resnull = false;
2420 
2421  /*
2422  * Note: current_schema() can return NULL. current_user() etc currently
2423  * cannot, but might as well code those cases the same way for safety.
2424  */
2425  switch (svf->op)
2426  {
2427  case SVFOP_CURRENT_DATE:
2428  *op->resvalue = DateADTGetDatum(GetSQLCurrentDate());
2429  break;
2430  case SVFOP_CURRENT_TIME:
2431  case SVFOP_CURRENT_TIME_N:
2432  *op->resvalue = TimeTzADTPGetDatum(GetSQLCurrentTime(svf->typmod));
2433  break;
2434  case SVFOP_CURRENT_TIMESTAMP:
2435  case SVFOP_CURRENT_TIMESTAMP_N:
2436  *op->resvalue = TimestampTzGetDatum(GetSQLCurrentTimestamp(svf->typmod));
2437  break;
2438  case SVFOP_LOCALTIME:
2439  case SVFOP_LOCALTIME_N:
2440  *op->resvalue = TimeADTGetDatum(GetSQLLocalTime(svf->typmod));
2441  break;
2442  case SVFOP_LOCALTIMESTAMP:
2443  case SVFOP_LOCALTIMESTAMP_N:
2444  *op->resvalue = TimestampGetDatum(GetSQLLocalTimestamp(svf->typmod));
2445  break;
2446  case SVFOP_CURRENT_ROLE:
2447  case SVFOP_CURRENT_USER:
2448  case SVFOP_USER:
2449  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2450  *op->resvalue = current_user(fcinfo);
2451  *op->resnull = fcinfo->isnull;
2452  break;
2453  case SVFOP_SESSION_USER:
2454  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2455  *op->resvalue = session_user(fcinfo);
2456  *op->resnull = fcinfo->isnull;
2457  break;
2458  case SVFOP_CURRENT_CATALOG:
2459  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2460  *op->resvalue = current_database(fcinfo);
2461  *op->resnull = fcinfo->isnull;
2462  break;
2463  case SVFOP_CURRENT_SCHEMA:
2464  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2465  *op->resvalue = current_schema(fcinfo);
2466  *op->resnull = fcinfo->isnull;
2467  break;
2468  }
2469 }
current_schema
Datum current_schema(PG_FUNCTION_ARGS)
Definition: name.c:279
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
TimeTzADTPGetDatum
#define TimeTzADTPGetDatum(X)
Definition: date.h:59
GetSQLCurrentTimestamp
TimestampTz GetSQLCurrentTimestamp(int32 typmod)
Definition: timestamp.c:1596
DateADTGetDatum
#define DateADTGetDatum(X)
Definition: date.h:57
GetSQLCurrentDate
DateADT GetSQLCurrentDate(void)
Definition: date.c:300
SQLValueFunction::op
SQLValueFunctionOp op
Definition: primnodes.h:1146
current_database
Datum current_database(PG_FUNCTION_ARGS)
Definition: misc.c:170
TimestampTzGetDatum
#define TimestampTzGetDatum(X)
Definition: timestamp.h:32
GetSQLCurrentTime
TimeTzADT * GetSQLCurrentTime(int32 typmod)
Definition: date.c:333
current_user
Datum current_user(PG_FUNCTION_ARGS)
Definition: name.c:263
ExprEvalStep::sqlvaluefunction
struct ExprEvalStep::@51::@68 sqlvaluefunction
TimestampGetDatum
#define TimestampGetDatum(X)
Definition: timestamp.h:31
GetSQLLocalTime
TimeADT GetSQLLocalTime(int32 typmod)
Definition: date.c:353
ExprEvalStep::d
union ExprEvalStep::@51 d
session_user
Datum session_user(PG_FUNCTION_ARGS)
Definition: name.c:269
TimeADTGetDatum
#define TimeADTGetDatum(X)
Definition: date.h:58
GetSQLLocalTimestamp
Timestamp GetSQLLocalTimestamp(int32 typmod)
Definition: timestamp.c:1610
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:36
LOCAL_FCINFO
#define LOCAL_FCINFO(name, nargs)
Definition: fmgr.h:110
InitFunctionCallInfoData
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:150

◆ ExecEvalStepOp()

ExprEvalOp ExecEvalStepOp ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 2262 of file execExprInterp.c.

References Assert, EEO_FLAG_DIRECT_THREADED, EEOP_LAST, ExprState::flags, sort-test::key, and ExprEvalStep::opcode.

Referenced by CheckExprStillValid(), and llvm_compile_expr().

2263 {
2264 #if defined(EEO_USE_COMPUTED_GOTO)
2265  if (state->flags & EEO_FLAG_DIRECT_THREADED)
2266  {
2267  ExprEvalOpLookup key;
2268  ExprEvalOpLookup *res;
2269 
2270  key.opcode = (void *) op->opcode;
2271  res = bsearch(&key,
2272  reverse_dispatch_table,
2273  EEOP_LAST /* nmembers */ ,
2274  sizeof(ExprEvalOpLookup),
2275  dispatch_compare_ptr);
2276  Assert(res); /* unknown ops shouldn't get looked up */
2277  return res->op;
2278  }
2279 #endif
2280  return (ExprEvalOp) op->opcode;
2281 }
ExprEvalOp
ExprEvalOp
Definition: execExpr.h:44
Assert
#define Assert(condition)
Definition: c.h:746
ExprEvalStep::opcode
intptr_t opcode
Definition: execExpr.h:249
ExprState::flags
uint8 flags
Definition: execnodes.h:64
EEO_FLAG_DIRECT_THREADED
#define EEO_FLAG_DIRECT_THREADED
Definition: execExpr.h:28

◆ ExecEvalSubPlan()

void ExecEvalSubPlan ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 3852 of file execExprInterp.c.

References check_stack_depth(), ExprEvalStep::d, ExecSubPlan(), ExprEvalStep::resnull, ExprEvalStep::resvalue, and ExprEvalStep::subplan.

Referenced by ExecInterpExpr().

3853 {
3854  SubPlanState *sstate = op->d.subplan.sstate;
3855 
3856  /* could potentially be nested, so make sure there's enough stack */
3857  check_stack_depth();
3858 
3859  *op->resvalue = ExecSubPlan(sstate, econtext, op->resnull);
3860 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ExprEvalStep::subplan
struct ExprEvalStep::@51::@87 subplan
check_stack_depth
void check_stack_depth(void)
Definition: postgres.c:3312
ExprEvalStep::d
union ExprEvalStep::@51 d
ExecSubPlan
Datum ExecSubPlan(SubPlanState *node, ExprContext *econtext, bool *isNull)
Definition: nodeSubplan.c:62

◆ ExecEvalSubscriptingRef()

bool ExecEvalSubscriptingRef ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3137 of file execExprInterp.c.

References ExprEvalStep::d, DatumGetInt32, ereport, errcode(), errmsg(), ERROR, SubscriptingRefState::isassignment, SubscriptingRefState::lowerindex, ExprEvalStep::resnull, ExprEvalStep::sbsref_subscript, SubscriptingRefState::subscriptnull, SubscriptingRefState::subscriptvalue, and SubscriptingRefState::upperindex.

Referenced by ExecInterpExpr().

3138 {
3139  SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
3140  int *indexes;
3141  int off;
3142 
3143  /* If any index expr yields NULL, result is NULL or error */
3144  if (sbsrefstate->subscriptnull)
3145  {
3146  if (sbsrefstate->isassignment)
3147  ereport(ERROR,
3148  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
3149  errmsg("array subscript in assignment must not be null")));
3150  *op->resnull = true;
3151  return false;
3152  }
3153 
3154  /* Convert datum to int, save in appropriate place */
3155  if (op->d.sbsref_subscript.isupper)
3156  indexes = sbsrefstate->upperindex;
3157  else
3158  indexes = sbsrefstate->lowerindex;
3159  off = op->d.sbsref_subscript.off;
3160 
3161  indexes[off] = DatumGetInt32(sbsrefstate->subscriptvalue);
3162 
3163  return true;
3164 }
DatumGetInt32
#define DatumGetInt32(X)
Definition: postgres.h:472
ExprEvalStep::sbsref_subscript
struct ExprEvalStep::@51::@78 sbsref_subscript
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
ERROR
#define ERROR
Definition: elog.h:43
ExprEvalStep::d
union ExprEvalStep::@51 d
ereport
#define ereport(elevel,...)
Definition: elog.h:144
SubscriptingRefState::lowerindex
int lowerindex[MAXDIM]
Definition: execExpr.h:659
SubscriptingRefState::upperindex
int upperindex[MAXDIM]
Definition: execExpr.h:654
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821

◆ ExecEvalSubscriptingRefAssign()

void ExecEvalSubscriptingRefAssign ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3261 of file execExprInterp.c.

References array_set_element(), array_set_slice(), construct_empty_array(), ExprEvalStep::d, SubscriptingRefState::lowerindex, SubscriptingRefState::lowerprovided, SubscriptingRefState::numlower, SubscriptingRefState::numupper, PointerGetDatum, SubscriptingRefState::refattrlength, SubscriptingRefState::refelemalign, SubscriptingRefState::refelembyval, SubscriptingRefState::refelemlength, SubscriptingRefState::refelemtype, SubscriptingRefState::replacenull, SubscriptingRefState::replacevalue, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref_subscript, SubscriptingRefState::upperindex, and SubscriptingRefState::upperprovided.

Referenced by ExecInterpExpr().

3262 {
3263  SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
3264 
3265  /*
3266  * For an assignment to a fixed-length container type, both the original
3267  * container and the value to be assigned into it must be non-NULL, else
3268  * we punt and return the original container.
3269  */
3270  if (sbsrefstate->refattrlength > 0)
3271  {
3272  if (*op->resnull || sbsrefstate->replacenull)
3273  return;
3274  }
3275 
3276  /*
3277  * For assignment to varlena arrays, we handle a NULL original array by
3278  * substituting an empty (zero-dimensional) array; insertion of the new
3279  * element will result in a singleton array value. It does not matter
3280  * whether the new element is NULL.
3281  */
3282  if (*op->resnull)
3283  {
3284  *op->resvalue = PointerGetDatum(construct_empty_array(sbsrefstate->refelemtype));
3285  *op->resnull = false;
3286  }
3287 
3288  if (sbsrefstate->numlower == 0)
3289  {
3290  /* Scalar case */
3291  *op->resvalue = array_set_element(*op->resvalue,
3292  sbsrefstate->numupper,
3293  sbsrefstate->upperindex,
3294  sbsrefstate->replacevalue,
3295  sbsrefstate->replacenull,
3296  sbsrefstate->refattrlength,
3297  sbsrefstate->refelemlength,
3298  sbsrefstate->refelembyval,
3299  sbsrefstate->refelemalign);
3300  }
3301  else
3302  {
3303  /* Slice case */
3304  *op->resvalue = array_set_slice(*op->resvalue,
3305  sbsrefstate->numupper,
3306  sbsrefstate->upperindex,
3307  sbsrefstate->lowerindex,
3308  sbsrefstate->upperprovided,
3309  sbsrefstate->lowerprovided,
3310  sbsrefstate->replacevalue,
3311  sbsrefstate->replacenull,
3312  sbsrefstate->refattrlength,
3313  sbsrefstate->refelemlength,
3314  sbsrefstate->refelembyval,
3315  sbsrefstate->refelemalign);
3316  }
3317 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::sbsref_subscript
struct ExprEvalStep::@51::@78 sbsref_subscript
PointerGetDatum
#define PointerGetDatum(X)
Definition: postgres.h:556
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
array_set_element
Datum array_set_element(Datum arraydatum, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2221
construct_empty_array
ArrayType * construct_empty_array(Oid elmtype)
Definition: arrayfuncs.c:3432
array_set_slice
Datum array_set_slice(Datum arraydatum, int nSubscripts, int *upperIndx, int *lowerIndx, bool *upperProvided, bool *lowerProvided, Datum srcArrayDatum, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2781
SubscriptingRefState::upperprovided
bool upperprovided[MAXDIM]
Definition: execExpr.h:653
ExprEvalStep::d
union ExprEvalStep::@51 d
SubscriptingRefState::lowerprovided
bool lowerprovided[MAXDIM]
Definition: execExpr.h:658
SubscriptingRefState::lowerindex
int lowerindex[MAXDIM]
Definition: execExpr.h:659
SubscriptingRefState::upperindex
int upperindex[MAXDIM]
Definition: execExpr.h:654

◆ ExecEvalSubscriptingRefFetch()

void ExecEvalSubscriptingRefFetch ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3172 of file execExprInterp.c.

References array_get_element(), array_get_slice(), Assert, ExprEvalStep::d, SubscriptingRefState::lowerindex, SubscriptingRefState::lowerprovided, SubscriptingRefState::numlower, SubscriptingRefState::numupper, SubscriptingRefState::refattrlength, SubscriptingRefState::refelemalign, SubscriptingRefState::refelembyval, SubscriptingRefState::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, SubscriptingRefState::upperindex, and SubscriptingRefState::upperprovided.

Referenced by ExecInterpExpr().

3173 {
3174  SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
3175 
3176  /* Should not get here if source container (or any subscript) is null */
3177  Assert(!(*op->resnull));
3178 
3179  if (sbsrefstate->numlower == 0)
3180  {
3181  /* Scalar case */
3182  *op->resvalue = array_get_element(*op->resvalue,
3183  sbsrefstate->numupper,
3184  sbsrefstate->upperindex,
3185  sbsrefstate->refattrlength,
3186  sbsrefstate->refelemlength,
3187  sbsrefstate->refelembyval,
3188  sbsrefstate->refelemalign,
3189  op->resnull);
3190  }
3191  else
3192  {
3193  /* Slice case */
3194  *op->resvalue = array_get_slice(*op->resvalue,
3195  sbsrefstate->numupper,
3196  sbsrefstate->upperindex,
3197  sbsrefstate->lowerindex,
3198  sbsrefstate->upperprovided,
3199  sbsrefstate->lowerprovided,
3200  sbsrefstate->refattrlength,
3201  sbsrefstate->refelemlength,
3202  sbsrefstate->refelembyval,
3203  sbsrefstate->refelemalign);
3204  }
3205 }
ExprEvalStep::sbsref
struct ExprEvalStep::@51::@79 sbsref
array_get_slice
Datum array_get_slice(Datum arraydatum, int nSubscripts, int *upperIndx, int *lowerIndx, bool *upperProvided, bool *lowerProvided, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2050
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
SubscriptingRefState::upperprovided
bool upperprovided[MAXDIM]
Definition: execExpr.h:653
ExprEvalStep::d
union ExprEvalStep::@51 d
SubscriptingRefState::lowerprovided
bool lowerprovided[MAXDIM]
Definition: execExpr.h:658
array_get_element
Datum array_get_element(Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:1841
Assert
#define Assert(condition)
Definition: c.h:746
SubscriptingRefState::lowerindex
int lowerindex[MAXDIM]
Definition: execExpr.h:659
SubscriptingRefState::upperindex
int upperindex[MAXDIM]
Definition: execExpr.h:654

◆ ExecEvalSubscriptingRefOld()

void ExecEvalSubscriptingRefOld ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3214 of file execExprInterp.c.

References array_get_element(), array_get_slice(), ExprEvalStep::d, SubscriptingRefState::lowerindex, SubscriptingRefState::lowerprovided, SubscriptingRefState::numlower, SubscriptingRefState::numupper, SubscriptingRefState::prevnull, SubscriptingRefState::prevvalue, SubscriptingRefState::refattrlength, SubscriptingRefState::refelemalign, SubscriptingRefState::refelembyval, SubscriptingRefState::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, SubscriptingRefState::upperindex, and SubscriptingRefState::upperprovided.

Referenced by ExecInterpExpr().

3215 {
3216  SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
3217 
3218  if (*op->resnull)
3219  {
3220  /* whole array is null, so any element or slice is too */
3221  sbsrefstate->prevvalue = (Datum) 0;
3222  sbsrefstate->prevnull = true;
3223  }
3224  else if (sbsrefstate->numlower == 0)
3225  {
3226  /* Scalar case */
3227  sbsrefstate->prevvalue = array_get_element(*op->resvalue,
3228  sbsrefstate->numupper,
3229  sbsrefstate->upperindex,
3230  sbsrefstate->refattrlength,
3231  sbsrefstate->refelemlength,
3232  sbsrefstate->refelembyval,
3233  sbsrefstate->refelemalign,
3234  &sbsrefstate->prevnull);
3235  }
3236  else
3237  {
3238  /* Slice case */
3239  /* this is currently unreachable */
3240  sbsrefstate->prevvalue = array_get_slice(*op->resvalue,
3241  sbsrefstate->numupper,
3242  sbsrefstate->upperindex,
3243  sbsrefstate->lowerindex,
3244  sbsrefstate->upperprovided,
3245  sbsrefstate->lowerprovided,
3246  sbsrefstate->refattrlength,
3247  sbsrefstate->refelemlength,
3248  sbsrefstate->refelembyval,
3249  sbsrefstate->refelemalign);
3250  sbsrefstate->prevnull = false;
3251  }
3252 }
ExprEvalStep::sbsref
struct ExprEvalStep::@51::@79 sbsref
array_get_slice
Datum array_get_slice(Datum arraydatum, int nSubscripts, int *upperIndx, int *lowerIndx, bool *upperProvided, bool *lowerProvided, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2050
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
SubscriptingRefState::upperprovided
bool upperprovided[MAXDIM]
Definition: execExpr.h:653
ExprEvalStep::d
union ExprEvalStep::@51 d
Datum
uintptr_t Datum
Definition: postgres.h:367
SubscriptingRefState::lowerprovided
bool lowerprovided[MAXDIM]
Definition: execExpr.h:658
array_get_element
Datum array_get_element(Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:1841
SubscriptingRefState::lowerindex
int lowerindex[MAXDIM]
Definition: execExpr.h:659
SubscriptingRefState::upperindex
int upperindex[MAXDIM]
Definition: execExpr.h:654

◆ ExecEvalSysVar()

void ExecEvalSysVar ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext,
TupleTableSlot *  slot 
)

Definition at line 4098 of file execExprInterp.c.

References ExprEvalStep::d, elog, ERROR, ExprEvalStep::resnull, ExprEvalStep::resvalue, slot_getsysattr(), unlikely, and ExprEvalStep::var.

Referenced by ExecInterpExpr().

4100 {
4101  Datum d;
4102 
4103  /* slot_getsysattr has sufficient defenses against bad attnums */
4104  d = slot_getsysattr(slot,
4105  op->d.var.attnum,
4106  op->resnull);
4107  *op->resvalue = d;
4108  /* this ought to be unreachable, but it's cheap enough to check */
4109  if (unlikely(*op->resnull))
4110  elog(ERROR, "failed to fetch attribute from slot");
4111 }
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
ERROR
#define ERROR
Definition: elog.h:43
ExprEvalStep::d
union ExprEvalStep::@51 d
Datum
uintptr_t Datum
Definition: postgres.h:367
ExprEvalStep::var
struct ExprEvalStep::@51::@53 var
elog
#define elog(elevel,...)
Definition: elog.h:214
unlikely
#define unlikely(x)
Definition: c.h:207
slot_getsysattr
static Datum slot_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:402

◆ ExecEvalWholeRowVar()

void ExecEvalWholeRowVar ( ExprState *  state,
ExprEvalStep *  op,
ExprContext *  econtext 
)

Definition at line 3869 of file execExprInterp.c.

References Assert, BlessTupleDesc(), Alias::colnames, CreateTupleDescCopy(), ExprEvalStep::d, ExprContext::ecxt_estate, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_per_query_memory, ExprContext::ecxt_scantuple, RangeTblEntry::eref, ereport, errcode(), errdetail(), errdetail_plural(), errmsg(), ERROR, EState::es_range_table_size, exec_rt_fetch(), ExecFilterJunk(), ExecTypeSetColNames(), format_type_be(), HeapTupleHeaderSetTypeId, HeapTupleHeaderSetTypMod, i, INNER_VAR, InvalidAttrNumber, lookup_rowtype_tupdesc_domain(), MemoryContextSwitchTo(), TupleDescData::natts, OUTER_VAR, PointerGetDatum, ReleaseTupleDesc, ExprEvalStep::resnull, ExprEvalStep::resvalue, slot_getallattrs(), HeapTupleData::t_data, toast_build_flattened_tuple(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleDescAttr, Var::varattno, Var::varno, Var::vartype, and ExprEvalStep::wholerow.

Referenced by ExecInterpExpr().

3870 {
3871  Var *variable = op->d.wholerow.var;
3872  TupleTableSlot *slot;
3873  TupleDesc output_tupdesc;
3874  MemoryContext oldcontext;
3875  HeapTupleHeader dtuple;
3876  HeapTuple tuple;
3877 
3878  /* This was checked by ExecInitExpr */
3879  Assert(variable->varattno == InvalidAttrNumber);
3880 
3881  /* Get the input slot we want */
3882  switch (variable->varno)
3883  {
3884  case INNER_VAR:
3885  /* get the tuple from the inner node */
3886  slot = econtext->ecxt_innertuple;
3887  break;
3888 
3889  case OUTER_VAR:
3890  /* get the tuple from the outer node */
3891  slot = econtext->ecxt_outertuple;
3892  break;
3893 
3894  /* INDEX_VAR is handled by default case */
3895 
3896  default:
3897  /* get the tuple from the relation being scanned */
3898  slot = econtext->ecxt_scantuple;
3899  break;
3900  }
3901 
3902  /* Apply the junkfilter if any */
3903  if (op->d.wholerow.junkFilter != NULL)
3904  slot = ExecFilterJunk(op->d.wholerow.junkFilter, slot);
3905 
3906  /*
3907  * If first time through, obtain tuple descriptor and check compatibility.
3908  *
3909  * XXX: It'd be great if this could be moved to the expression
3910  * initialization phase, but due to using slots that's currently not
3911  * feasible.
3912  */
3913  if (op->d.wholerow.first)
3914  {
3915  /* optimistically assume we don't need slow path */
3916  op->d.wholerow.slow = false;
3917 
3918  /*
3919  * If the Var identifies a named composite type, we must check that
3920  * the actual tuple type is compatible with it.
3921  */
3922  if (variable->vartype != RECORDOID)
3923  {
3924  TupleDesc var_tupdesc;
3925  TupleDesc slot_tupdesc;
3926 
3927  /*
3928  * We really only care about numbers of attributes and data types.
3929  * Also, we can ignore type mismatch on columns that are dropped
3930  * in the destination type, so long as (1) the physical storage
3931  * matches or (2) the actual column value is NULL. Case (1) is
3932  * helpful in some cases involving out-of-date cached plans, while
3933  * case (2) is expected behavior in situations such as an INSERT
3934  * into a table with dropped columns (the planner typically
3935  * generates an INT4 NULL regardless of the dropped column type).
3936  * If we find a dropped column and cannot verify that case (1)
3937  * holds, we have to use the slow path to check (2) for each row.
3938  *
3939  * If vartype is a domain over composite, just look through that
3940  * to the base composite type.
3941  */
3942  var_tupdesc = lookup_rowtype_tupdesc_domain(variable->vartype,
3943  -1, false);
3944 
3945  slot_tupdesc = slot->tts_tupleDescriptor;
3946 
3947  if (var_tupdesc->natts != slot_tupdesc->natts)
3948  ereport(ERROR,
3949  (errcode(ERRCODE_DATATYPE_MISMATCH),
3950  errmsg("table row type and query-specified row type do not match"),
3951  errdetail_plural("Table row contains %d attribute, but query expects %d.",
3952  "Table row contains %d attributes, but query expects %d.",
3953  slot_tupdesc->natts,
3954  slot_tupdesc->natts,
3955  var_tupdesc->natts)));
3956 
3957  for (int i = 0; i < var_tupdesc->natts; i++)
3958  {
3959  Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
3960  Form_pg_attribute sattr = TupleDescAttr(slot_tupdesc, i);
3961 
3962  if (vattr->atttypid == sattr->atttypid)
3963  continue; /* no worries */
3964  if (!vattr->attisdropped)
3965  ereport(ERROR,
3966  (errcode(ERRCODE_DATATYPE_MISMATCH),
3967  errmsg("table row type and query-specified row type do not match"),
3968  errdetail("Table has type %s at ordinal position %d, but query expects %s.",
3969  format_type_be(sattr->atttypid),
3970  i + 1,
3971  format_type_be(vattr->atttypid))));
3972 
3973  if (vattr->attlen != sattr->attlen ||
3974  vattr->attalign != sattr->attalign)
3975  op->d.wholerow.slow = true; /* need to check for nulls */
3976  }
3977 
3978  /*
3979  * Use the variable's declared rowtype as the descriptor for the
3980  * output values, modulo possibly assigning new column names
3981  * below. In particular, we *must* absorb any attisdropped
3982  * markings.
3983  */
3984  oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
3985  output_tupdesc = CreateTupleDescCopy(var_tupdesc);
3986  MemoryContextSwitchTo(oldcontext);
3987 
3988  ReleaseTupleDesc(var_tupdesc);
3989  }
3990  else
3991  {
3992  /*
3993  * In the RECORD case, we use the input slot's rowtype as the
3994  * descriptor for the output values, modulo possibly assigning new
3995  * column names below.
3996  */
3997  oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
3998  output_tupdesc = CreateTupleDescCopy(slot->tts_tupleDescriptor);
3999  MemoryContextSwitchTo(oldcontext);
4000  }
4001 
4002  /*
4003  * Construct a tuple descriptor for the composite values we'll
4004  * produce, and make sure its record type is "blessed". The main
4005  * reason to do this is to be sure that operations such as
4006  * row_to_json() will see the desired column names when they look up
4007  * the descriptor from the type information embedded in the composite
4008  * values.
4009  *
4010  * We already got the correct physical datatype info above, but now we
4011  * should try to find the source RTE and adopt its column aliases, in
4012  * case they are different from the original rowtype's names. For
4013  * example, in "SELECT foo(t) FROM tab t(x,y)", the first two columns
4014  * in the composite output should be named "x" and "y" regardless of
4015  * tab's column names.
4016  *
4017  * If we can't locate the RTE, assume the column names we've got are
4018  * OK. (As of this writing, the only cases where we can't locate the
4019  * RTE are in execution of trigger WHEN clauses, and then the Var will
4020  * have the trigger's relation's rowtype, so its names are fine.)
4021  * Also, if the creator of the RTE didn't bother to fill in an eref
4022  * field, assume our column names are OK. (This happens in COPY, and
4023  * perhaps other places.)
4024  */
4025  if (econtext->ecxt_estate &&
4026  variable->varno <= econtext->ecxt_estate->es_range_table_size)
4027  {
4028  RangeTblEntry *rte = exec_rt_fetch(variable->varno,
4029  econtext->ecxt_estate);
4030 
4031  if (rte->eref)
4032  ExecTypeSetColNames(output_tupdesc, rte->eref->colnames);
4033  }
4034 
4035  /* Bless the tupdesc if needed, and save it in the execution state */
4036  op->d.wholerow.tupdesc = BlessTupleDesc(output_tupdesc);
4037 
4038  op->d.wholerow.first = false;
4039  }
4040 
4041  /*
4042  * Make sure all columns of the slot are accessible in the slot's
4043  * Datum/isnull arrays.
4044  */
4045  slot_getallattrs(slot);
4046 
4047  if (op->d.wholerow.slow)
4048  {
4049  /* Check to see if any dropped attributes are non-null */
4050  TupleDesc tupleDesc = slot->tts_tupleDescriptor;
4051  TupleDesc var_tupdesc = op->d.wholerow.tupdesc;
4052 
4053  Assert(var_tupdesc->natts == tupleDesc->natts);
4054 
4055  for (int i = 0; i < var_tupdesc->natts; i++)
4056  {
4057  Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
4058  Form_pg_attribute sattr = TupleDescAttr(tupleDesc, i);
4059 
4060  if (!vattr->attisdropped)
4061  continue; /* already checked non-dropped cols */
4062  if (slot->tts_isnull[i])
4063  continue; /* null is always okay */
4064  if (vattr->attlen != sattr->attlen ||
4065  vattr->attalign != sattr->attalign)
4066  ereport(ERROR,
4067  (errcode(ERRCODE_DATATYPE_MISMATCH),
4068  errmsg("table row type and query-specified row type do not match"),
4069  errdetail("Physical storage mismatch on dropped attribute at ordinal position %d.",
4070  i + 1)));
4071  }
4072  }
4073 
4074  /*
4075  * Build a composite datum, making sure any toasted fields get detoasted.
4076  *
4077  * (Note: it is critical that we not change the slot's state here.)
4078  */
4079  tuple = toast_build_flattened_tuple(slot->tts_tupleDescriptor,
4080  slot->tts_values,
4081  slot->tts_isnull);
4082  dtuple = tuple->t_data;
4083 
4084  /*
4085  * Label the datum with the composite type info we identified before.
4086  *
4087  * (Note: we could skip doing this by passing op->d.wholerow.tupdesc to
4088  * the tuple build step; but that seems a tad risky so let's not.)
4089  */
4090  HeapTupleHeaderSetTypeId(dtuple, op->d.wholerow.tupdesc->tdtypeid);
4091  HeapTupleHeaderSetTypMod(dtuple, op->d.wholerow.tupdesc->tdtypmod);
4092 
4093  *op->resvalue = PointerGetDatum(dtuple);
4094  *op->resnull = false;
4095 }
CreateTupleDescCopy
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:110
HeapTupleHeaderSetTypeId
#define HeapTupleHeaderSetTypeId(tup, typeid)
Definition: htup_details.h:463
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
Alias::colnames
List * colnames
Definition: primnodes.h:43
PointerGetDatum
#define PointerGetDatum(X)
Definition: postgres.h:556
TupleDescAttr
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
Var::varattno
AttrNumber varattno
Definition: primnodes.h:186
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
Var
Definition: primnodes.h:181
lookup_rowtype_tupdesc_domain
TupleDesc lookup_rowtype_tupdesc_domain(Oid type_id, int32 typmod, bool noError)
Definition: typcache.c:1766
HeapTupleData::t_data
HeapTupleHeader t_data
Definition: htup.h:68
ERROR
#define ERROR
Definition: elog.h:43
Var::vartype
Oid vartype
Definition: primnodes.h:188
slot_getallattrs
static void slot_getallattrs(TupleTableSlot *slot)
Definition: tuptable.h:354
BlessTupleDesc
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2052
toast_build_flattened_tuple
HeapTuple toast_build_flattened_tuple(TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptoast.c:563
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:954
ExprContext::ecxt_innertuple
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:227
ExprContext::ecxt_estate
struct EState * ecxt_estate
Definition: execnodes.h:261
exec_rt_fetch
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition: executor.h:544
Form_pg_attribute
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
ExprEvalStep::d
union ExprEvalStep::@51 d
Var::varno
Index varno
Definition: primnodes.h:184
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
ExecFilterJunk
TupleTableSlot * ExecFilterJunk(JunkFilter *junkfilter, TupleTableSlot *slot)
Definition: execJunk.c:261
HeapTupleHeaderSetTypMod
#define HeapTupleHeaderSetTypMod(tup, typmod)
Definition: htup_details.h:473
ereport
#define ereport(elevel,...)
Definition: elog.h:144
INNER_VAR
#define INNER_VAR
Definition: primnodes.h:171
ExprContext::ecxt_outertuple
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:229
Assert
#define Assert(condition)
Definition: c.h:746
errdetail_plural
int errdetail_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1046
ExprContext::ecxt_scantuple
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:225
EState::es_range_table_size
Index es_range_table_size
Definition: execnodes.h:520
ExprContext::ecxt_per_query_memory
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:232
InvalidAttrNumber
#define InvalidAttrNumber
Definition: attnum.h:23
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:821
i
int i
Definition: preproc-comment.c:23
RangeTblEntry::eref
Alias * eref
Definition: parsenodes.h:1116
ExprEvalStep::wholerow
struct ExprEvalStep::@51::@54 wholerow
ReleaseTupleDesc
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122
OUTER_VAR
#define OUTER_VAR
Definition: primnodes.h:172
ExecTypeSetColNames
void ExecTypeSetColNames(TupleDesc typeInfo, List *namesList)
Definition: execTuples.c:2006

◆ ExecEvalXmlExpr()

void ExecEvalXmlExpr ( ExprState *  state,
ExprEvalStep *  op 
)

Definition at line 3608 of file execExprInterp.c.

References appendStringInfo(), arg, XmlExpr::arg_names, XmlExpr::args, Assert, BoolGetDatum, buf, cstring_to_text_with_len(), ExprEvalStep::d, StringInfoData::data, DatumGetBool, DatumGetInt32, DatumGetPointer, DatumGetTextPP, DatumGetXmlP, elog, ERROR, exprType(), forboth, i, initStringInfo(), IS_DOCUMENT, IS_XMLCONCAT, IS_XMLELEMENT, IS_XMLFOREST, IS_XMLPARSE, IS_XMLPI, IS_XMLROOT, IS_XMLSERIALIZE, lappend(), StringInfoData::len, lfirst, list_length(), map_sql_value_to_xml_value(), XmlExpr::name, XmlExpr::named_args, NIL, XmlExpr::op, pfree(), PointerGetDatum, ExprEvalStep::resnull, ExprEvalStep::resvalue, strVal, value, values, xml_is_document(), xmlconcat(), xmlelement(), ExprEvalStep::xmlexpr, XmlExpr::xmloption, xmlparse(), xmlpi(), xmlroot(), and xmltotext_with_xmloption().

Referenced by ExecInterpExpr().

3609 {
3610  XmlExpr *xexpr = op->d.xmlexpr.xexpr;
3611  Datum value;
3612 
3613  *op->resnull = true; /* until we get a result */
3614  *op->resvalue = (Datum) 0;
3615 
3616  switch (xexpr->op)
3617  {
3618  case IS_XMLCONCAT:
3619  {
3620  Datum *argvalue = op->d.xmlexpr.argvalue;
3621  bool *argnull = op->d.xmlexpr.argnull;
3622  List *values = NIL;
3623 
3624  for (int i = 0; i < list_length(xexpr->args); i++)
3625  {
3626  if (!argnull[i])
3627  values = lappend(values, DatumGetPointer(argvalue[i]));
3628  }
3629 
3630  if (values != NIL)
3631  {
3632  *op->resvalue = PointerGetDatum(xmlconcat(values));
3633  *op->resnull = false;
3634  }
3635  }
3636  break;
3637 
3638  case IS_XMLFOREST:
3639  {
3640  Datum *argvalue = op->d.xmlexpr.named_argvalue;
3641  bool *argnull = op->d.xmlexpr.named_argnull;
3642  StringInfoData buf;
3643  ListCell *lc;
3644  ListCell *lc2;
3645  int i;
3646 
3647  initStringInfo(&buf);
3648 
3649  i = 0;
3650  forboth(lc, xexpr->named_args, lc2, xexpr->arg_names)
3651  {
3652  Expr *e = (Expr *) lfirst(lc);
3653  char *argname = strVal(lfirst(lc2));
3654 
3655  if (!argnull[i])
3656  {
3657  value = argvalue[i];
3658  appendStringInfo(&buf, "<%s>%s</%s>",
3659  argname,
3660  map_sql_value_to_xml_value(value,
3661  exprType((Node *) e), true),
3662  argname);
3663  *op->resnull = false;
3664  }
3665  i++;
3666  }
3667 
3668  if (!*op->resnull)
3669  {
3670  text *result;
3671 
3672  result = cstring_to_text_with_len(buf.data, buf.len);
3673  *op->resvalue = PointerGetDatum(result);
3674  }
3675 
3676  pfree(buf.data);
3677  }
3678  break;
3679 
3680  case IS_XMLELEMENT:
3681  *op->resvalue = PointerGetDatum(xmlelement(xexpr,
3682  op->d.xmlexpr.named_argvalue,
3683  op->d.xmlexpr.named_argnull,
3684  op->d.xmlexpr.argvalue,
3685  op->d.xmlexpr.argnull));
3686  *op->resnull = false;
3687  break;
3688 
3689  case IS_XMLPARSE:
3690  {
3691  Datum *argvalue = op->d.xmlexpr.argvalue;
3692  bool *argnull = op->d.xmlexpr.argnull;
3693  text *data;
3694  bool preserve_whitespace;
3695 
3696  /* arguments are known to be text, bool */
3697  Assert(list_length(xexpr->args) == 2);
3698 
3699  if (argnull[0])
3700  return;
3701  value = argvalue[0];
3702  data = DatumGetTextPP(value);
3703 
3704  if (argnull[1]) /* probably can't happen */
3705  return;
3706  value = argvalue[1];
3707  preserve_whitespace = DatumGetBool(value);
3708 
3709  *op->resvalue = PointerGetDatum(xmlparse(data,
3710  xexpr->xmloption,
3711  preserve_whitespace));
3712  *op->resnull = false;
3713  }
3714  break;
3715 
3716  case IS_XMLPI:
3717  {
3718  text *arg;
3719  bool isnull;
3720 
3721  /* optional argument is known to be text */
3722  Assert(list_length(xexpr->args) <= 1);
3723 
3724  if (xexpr->args)
3725  {
3726  isnull = op->d.xmlexpr.argnull[0];
3727  if (isnull)
3728  arg = NULL;
3729  else
3730  arg = DatumGetTextPP(op->d.xmlexpr.argvalue[0]);
3731  }
3732  else
3733  {
3734  arg = NULL;
3735  isnull = false;
3736  }
3737 
3738  *op->resvalue = PointerGetDatum(xmlpi(xexpr->name,
3739  arg,
3740  isnull,
3741  op->resnull));
3742  }
3743  break;
3744 
3745  case IS_XMLROOT:
3746  {
3747  Datum *argvalue = op->d.xmlexpr.argvalue;
3748  bool *argnull = op->d.xmlexpr.argnull;
3749  xmltype *data;
3750  text *version;
3751  int standalone;
3752 
3753  /* arguments are known to be xml, text, int */
3754  Assert(list_length(xexpr->args) == 3);
3755 
3756  if (argnull[0])
3757  return;
3758  data = DatumGetXmlP(argvalue[0]);
3759 
3760  if (argnull[1])
3761  version = NULL;
3762  else
3763  version = DatumGetTextPP(argvalue[1]);
3764 
3765  Assert(!argnull[2]); /* always present */
3766  standalone = DatumGetInt32(argvalue[2]);
3767 
3768  *op->resvalue = PointerGetDatum(xmlroot(data,
3769  version,
3770  standalone));
3771  *op->resnull = false;
3772  }
3773  break;
3774 
3775  case IS_XMLSERIALIZE:
3776  {
3777  Datum *argvalue = op->d.xmlexpr.argvalue;
3778  bool *argnull = op->d.xmlexpr.argnull;
3779 
3780  /* argument type is known to be xml */
3781  Assert(list_length(xexpr->args) == 1);
3782 
3783  if (argnull[0])
3784  return;
3785  value = argvalue[0];
3786 
3787  *op->resvalue = PointerGetDatum(xmltotext_with_xmloption(DatumGetXmlP(value),
3788  xexpr->xmloption));
3789  *op->resnull = false;
3790  }
3791  break;
3792 
3793  case IS_DOCUMENT:
3794  {
3795  Datum *argvalue = op->d.xmlexpr.argvalue;
3796  bool *argnull = op->d.xmlexpr.argnull;
3797 
3798  /* optional argument is known to be xml */
3799  Assert(list_length(xexpr->args) == 1);
3800 
3801  if (argnull[0])
3802  return;
3803  value = argvalue[0];
3804 
3805  *op->resvalue =
3806  BoolGetDatum(xml_is_document(DatumGetXmlP(value)));
3807  *op->resnull = false;
3808  }
3809  break;
3810 
3811  default:
3812  elog(ERROR, "unrecognized XML operation");
3813  break;
3814  }
3815 }
NIL
#define NIL
Definition: pg_list.h:65
forboth
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:434
XmlExpr::name
char * name
Definition: primnodes.h:1185
ExprEvalStep::resvalue
Datum * resvalue
Definition: execExpr.h:252
DatumGetInt32
#define DatumGetInt32(X)
Definition: postgres.h:472
PointerGetDatum
#define PointerGetDatum(X)
Definition: postgres.h:556
DatumGetTextPP
#define DatumGetTextPP(X)
Definition: fmgr.h:291
ExprEvalStep::resnull
bool * resnull
Definition: execExpr.h:253
xmlconcat
xmltype * xmlconcat(List *args)
Definition: xml.c:512
Node
Definition: nodes.h:528
strVal
#define strVal(v)
Definition: value.h:54
XmlExpr::arg_names
List * arg_names
Definition: primnodes.h:1187
DatumGetXmlP
#define DatumGetXmlP(X)
Definition: xml.h:50
xmlpi
xmltype * xmlpi(const char *target, text *arg, bool arg_is_null, bool *result_is_null)
Definition: xml.c:770
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
appendStringInfo
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
ERROR
#define ERROR
Definition: elog.h:43
xmltotext_with_xmloption
text * xmltotext_with_xmloption(xmltype *data, XmlOptionType xmloption_arg)
Definition: xml.c:615
buf
static char * buf
Definition: pg_test_fsync.c:68
cstring_to_text_with_len
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:200
xmlroot
xmltype * xmlroot(xmltype *data, text *version, int standalone)
Definition: xml.c:822
DatumGetBool
#define DatumGetBool(X)
Definition: postgres.h:393
ExprEvalStep::d
union ExprEvalStep::@51 d
lappend
List * lappend(List *list, void *datum)
Definition: list.c:321
xml_is_document
bool xml_is_document(xmltype *arg)
Definition: xml.c:888
initStringInfo
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
XmlExpr::op
XmlExprOp op
Definition: primnodes.h:1184
Datum
uintptr_t Datum
Definition: postgres.h:367
BoolGetDatum
#define BoolGetDatum(X)
Definition: postgres.h:402
ExprEvalStep::xmlexpr
struct ExprEvalStep::@51::@83 xmlexpr
XmlExpr::named_args
List * named_args
Definition: primnodes.h:1186
value
static struct @143 value
XmlExpr::args
List * args
Definition: primnodes.h:1188
Assert
#define Assert(condition)
Definition: c.h:746
lfirst
#define lfirst(lc)
Definition: pg_list.h:169
XmlExpr::xmloption
XmlOptionType xmloption
Definition: primnodes.h:1189
exprType
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
list_length
static int list_length(const List *l)
Definition: pg_list.h:149
DatumGetPointer
#define DatumGetPointer(X)
Definition: postgres.h:549
values
static Datum values[MAXATTR]
Definition: bootstrap.c:165
e
e
Definition: preproc-init.c:82
elog
#define elog(elevel,...)
Definition: elog.h:214
i
int i
Definition: preproc-comment.c:23
xmlelement
xmltype * xmlelement(XmlExpr *xexpr, Datum *named_argvalue, bool *named_argnull, Datum *argvalue, bool *argnull)
Definition: xml.c:628
arg
void * arg
Definition: pg_backup_utils.c:27
varlena
Definition: c.h:563
map_sql_value_to_xml_value
char * map_sql_value_to_xml_value(Datum value, Oid type, bool xml_escape_strings)
Definition: xml.c:2134
List
Definition: pg_list.h:50
xmlparse
xmltype * xmlparse(text *data, XmlOptionType xmloption_arg, bool preserve_whitespace)
Definition: xml.c:752

◆ ExecInterpExprStillValid()

Datum ExecInterpExprStillValid ( ExprState *  state,
ExprContext *  econtext,
bool *  isNull 
)

Definition at line 1781 of file execExprInterp.c.

References CheckExprStillValid(), ExprState::evalfunc, and ExprState::evalfunc_private.

Referenced by ExecReadyInterpretedExpr().

1782 {
1783  /*
1784  * First time through, check whether attribute matches Var. Might not be
1785  * ok anymore, due to schema changes.
1786  */
1787  CheckExprStillValid(state, econtext);
1788 
1789  /* skip the check during further executions */
1790  state->evalfunc = (ExprStateEvalFunc) state->evalfunc_private;
1791 
1792  /* and actually execute */
1793  return state->evalfunc(state, econtext, isNull);
1794 }
ExprStateEvalFunc
Datum(* ExprStateEvalFunc)(struct ExprState *expression, struct ExprContext *econtext, bool *isNull)
Definition: execnodes.h:52
ExprState::evalfunc
ExprStateEvalFunc evalfunc
Definition: execnodes.h:90
ExprState::evalfunc_private
void * evalfunc_private
Definition: execnodes.h:96
CheckExprStillValid
void CheckExprStillValid(ExprState *state, ExprContext *econtext)
Definition: execExprInterp.c:1801

◆ ExecReadyInterpretedExpr()

void ExecReadyInterpretedExpr ( ExprState *  state)

Definition at line 185 of file execExprInterp.c.

References Assert, ExprEvalStep::casetest, ExprEvalStep::d, EEO_FLAG_DIRECT_THREADED, EEO_FLAG_INTERPRETER_INITIALIZED, EEO_OPCODE, EEOP_ASSIGN_INNER_VAR, EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_CASE_TESTVAL, EEOP_CONST, EEOP_DONE, EEOP_FUNCEXPR_STRICT, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, EEOP_OUTER_FETCHSOME, EEOP_OUTER_VAR, EEOP_SCAN_FETCHSOME, EEOP_SCAN_VAR, ExprState::evalfunc, ExprState::evalfunc_private, ExecInitInterpreter(), ExecInterpExpr(), ExecInterpExprStillValid(), ExecJustApplyFuncToCase(), ExecJustAssignInnerVar(), ExecJustAssignInnerVarVirt(), ExecJustAssignOuterVar(), ExecJustAssignOuterVarVirt(), ExecJustAssignScanVar(), ExecJustAssignScanVarVirt(), ExecJustConst(), ExecJustInnerVar(), ExecJustInnerVarVirt(), ExecJustOuterVar(), ExecJustOuterVarVirt(), ExecJustScanVar(), ExecJustScanVarVirt(), ExprState::flags, ExprEvalStep::opcode, ExprState::steps, and ExprState::steps_len.

Referenced by ExecReadyExpr().

186 {
187  /* Ensure one-time interpreter setup has been done */
188  ExecInitInterpreter();
189 
190  /* Simple validity checks on expression */
191  Assert(state->steps_len >= 1);
192  Assert(state->steps[state->steps_len - 1].opcode == EEOP_DONE);
193 
194  /*
195  * Don't perform redundant initialization. This is unreachable in current
196  * cases, but might be hit if there's additional expression evaluation
197  * methods that rely on interpreted execution to work.
198  */
199  if (state->flags & EEO_FLAG_INTERPRETER_INITIALIZED)
200  return;
201 
202  /*
203  * First time through, check whether attribute matches Var. Might not be
204  * ok anymore, due to schema changes. We do that by setting up a callback
205  * that does checking on the first call, which then sets the evalfunc
206  * callback to the actual method of execution.
207  */
208  state->evalfunc = ExecInterpExprStillValid;
209 
210  /* DIRECT_THREADED should not already be set */
211  Assert((state->flags & EEO_FLAG_DIRECT_THREADED) == 0);
212 
213  /*
214  * There shouldn't be any errors before the expression is fully
215  * initialized, and even if so, it'd lead to the expression being
216  * abandoned. So we can set the flag now and save some code.
217  */
218  state->flags |= EEO_FLAG_INTERPRETER_INITIALIZED;
219 
220  /*
221  * Select fast-path evalfuncs for very simple expressions. "Starting up"
222  * the full interpreter is a measurable overhead for these, and these
223  * patterns occur often enough to be worth optimizing.
224  */
225  if (state->steps_len == 3)
226  {
227  ExprEvalOp step0 = state->steps[0].opcode;
228  ExprEvalOp step1 = state->steps[1].opcode;
229 
230  if (step0 == EEOP_INNER_FETCHSOME &&
231  step1 == EEOP_INNER_VAR)
232  {
233  state->evalfunc_private = (void *) ExecJustInnerVar;
234  return;
235  }
236  else if (step0 == EEOP_OUTER_FETCHSOME &&
237  step1 == EEOP_OUTER_VAR)
238  {
239  state->evalfunc_private = (void *) ExecJustOuterVar;
240  return;
241  }
242  else if (step0 == EEOP_SCAN_FETCHSOME &&
243  step1 == EEOP_SCAN_VAR)
244  {
245  state->evalfunc_private = (void *) ExecJustScanVar;
246  return;
247  }
248  else if (step0 == EEOP_INNER_FETCHSOME &&
249  step1 == EEOP_ASSIGN_INNER_VAR)
250  {
251  state->evalfunc_private = (void *) ExecJustAssignInnerVar;
252  return;
253  }
254  else if (step0 == EEOP_OUTER_FETCHSOME &&
255  step1 == EEOP_ASSIGN_OUTER_VAR)
256  {
257  state->evalfunc_private = (void *) ExecJustAssignOuterVar;
258  return;
259  }
260  else if (step0 == EEOP_SCAN_FETCHSOME &&
261  step1 == EEOP_ASSIGN_SCAN_VAR)
262  {
263  state->evalfunc_private = (void *) ExecJustAssignScanVar;
264  return;
265  }
266  else if (step0 == EEOP_CASE_TESTVAL &&
267  step1 == EEOP_FUNCEXPR_STRICT &&
268  state->steps[0].d.casetest.value)
269  {
270  state->evalfunc_private = (void *) ExecJustApplyFuncToCase;
271  return;
272  }
273  }
274  else if (state->steps_len == 2)
275  {
276  ExprEvalOp step0 = state->steps[0].opcode;
277 
278  if (step0 == EEOP_CONST)
279  {
280  state->evalfunc_private = (void *) ExecJustConst;
281  return;
282  }
283  else if (step0 == EEOP_INNER_VAR)
284  {
285  state->evalfunc_private = (void *) ExecJustInnerVarVirt;
286  return;
287  }
288  else if (step0 == EEOP_OUTER_VAR)
289  {
290  state->evalfunc_private = (void *) ExecJustOuterVarVirt;
291  return;
292  }
293  else if (step0 == EEOP_SCAN_VAR)
294  {
295  state->evalfunc_private = (void *) ExecJustScanVarVirt;
296  return;
297  }
298  else if (step0 == EEOP_ASSIGN_INNER_VAR)
299  {
300  state->evalfunc_private = (void *) ExecJustAssignInnerVarVirt;
301  return;
302  }
303  else if (step0 == EEOP_ASSIGN_OUTER_VAR)
304  {
305  state->evalfunc_private = (void *) ExecJustAssignOuterVarVirt;
306  return;
307  }
308  else if (step0 == EEOP_ASSIGN_SCAN_VAR)
309  {
310  state->evalfunc_private = (void *) ExecJustAssignScanVarVirt;
311  return;
312  }
313  }
314 
315 #if defined(EEO_USE_COMPUTED_GOTO)
316 
317  /*
318  * In the direct-threaded implementation, replace each opcode with the
319  * address to jump to. (Use ExecEvalStepOp() to get back the opcode.)
320  */
321  for (int off = 0; off < state->steps_len; off++)
322  {
323  ExprEvalStep *op = &state->steps[off];
324 
325  op->opcode = EEO_OPCODE(op->opcode);
326  }
327 
328  state->flags |= EEO_FLAG_DIRECT_THREADED;
329 #endif /* EEO_USE_COMPUTED_GOTO */
330 
331  state->evalfunc_private = (void *) ExecInterpExpr;
332 }
ExecInterpExprStillValid
Datum ExecInterpExprStillValid(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: execExprInterp.c:1781
ExecJustOuterVar
static Datum ExecJustOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2017
ExecJustScanVar
static Datum ExecJustScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2024
ExecJustInnerVarVirt
static Datum ExecJustInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2146
ExprState::steps
struct ExprEvalStep * steps
Definition: execnodes.h:84
ExprEvalOp
ExprEvalOp
Definition: execExpr.h:44
ExecJustConst
static Datum ExecJustConst(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2114
ExprState::evalfunc
ExprStateEvalFunc evalfunc
Definition: execnodes.h:90
ExecJustInnerVar
static Datum ExecJustInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2010
ExecJustAssignOuterVar
static Datum ExecJustAssignOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2062
ExprState::evalfunc_private
void * evalfunc_private
Definition: execnodes.h:96
ExprEvalStep::d
union ExprEvalStep::@51 d
ExecJustApplyFuncToCase
static Datum ExecJustApplyFuncToCase(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2076
ExecJustAssignOuterVarVirt
static Datum ExecJustAssignOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2195
ExecJustScanVarVirt
static Datum ExecJustScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2160
ExecJustAssignScanVarVirt
static Datum ExecJustAssignScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2202
Assert
#define Assert(condition)
Definition: c.h:746
ExprEvalStep::opcode
intptr_t opcode
Definition: execExpr.h:249
ExecJustAssignScanVar
static Datum ExecJustAssignScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2069
ExecInitInterpreter
static void ExecInitInterpreter(void)
Definition: execExprInterp.c:2230
ExprEvalStep::casetest
struct ExprEvalStep::@51::@65 casetest
ExecInterpExpr
static Datum ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:345
ExecJustOuterVarVirt
static Datum ExecJustOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2153
ExprState::steps_len
int steps_len
Definition: execnodes.h:103
ExecJustAssignInnerVarVirt
static Datum ExecJustAssignInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2188
ExecJustAssignInnerVar
static Datum ExecJustAssignInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition: execExprInterp.c:2055
ExprState::flags
uint8 flags
Definition: execnodes.h:64
EEO_OPCODE
#define EEO_OPCODE(opcode)
Definition: execExprInterp.c:124
EEO_FLAG_INTERPRETER_INITIALIZED
#define EEO_FLAG_INTERPRETER_INITIALIZED
Definition: execExpr.h:26
EEO_FLAG_DIRECT_THREADED
#define EEO_FLAG_DIRECT_THREADED
Definition: execExpr.h:28

◆ ExprEvalPushStep()

void ExprEvalPushStep ( ExprState *  es,
const ExprEvalStep *  s 
)

Definition at line 2108 of file execExpr.c.

References palloc(), repalloc(), ExprState::steps, ExprState::steps_alloc, and ExprState::steps_len.

Referenced by ExecBuildAggTrans(), ExecBuildAggTransCall(), ExecBuildGroupingEqual(), ExecBuildProjectionInfo(), ExecInitCoerceToDomain(), ExecInitExpr(), ExecInitExprRec(), ExecInitExprWithParams(), ExecInitQual(), ExecInitSubscriptingRef(), ExecPushExprSlots(), and plpgsql_param_compile().

2109 {
2110  if (es->steps_alloc == 0)
2111  {
2112  es->steps_alloc = 16;
2113  es->steps = palloc(sizeof(ExprEvalStep) * es->steps_alloc);
2114  }
2115  else if (es->steps_alloc == es->steps_len)
2116  {
2117  es->steps_alloc *= 2;
2118  es->steps = repalloc(es->steps,
2119  sizeof(ExprEvalStep) * es->steps_alloc);
2120  }
2121 
2122  memcpy(&es->steps[es->steps_len++], s, sizeof(ExprEvalStep));
2123 }
ExprState::steps
struct ExprEvalStep * steps
Definition: execnodes.h:84
repalloc
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1070
ExprState::steps_alloc
int steps_alloc
Definition: execnodes.h:104
palloc
void * palloc(Size size)
Definition: mcxt.c:950
ExprState::steps_len
int steps_len
Definition: execnodes.h:103