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

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 bool(* ExecEvalBoolSubroutine) (ExprState *state, struct ExprEvalStep *op, ExprContext *econtext)
 
typedef enum ExprEvalOp ExprEvalOp
 
typedef struct ExprEvalStep ExprEvalStep
 
typedef struct SubscriptingRefState SubscriptingRefState
 
typedef struct SubscriptExecSteps SubscriptExecSteps
 

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_SUBSCRIPTS, 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)
 
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

◆ ExecEvalBoolSubroutine

typedef bool(* ExecEvalBoolSubroutine) (ExprState *state, struct ExprEvalStep *op, ExprContext *econtext)

Definition at line 36 of file execExpr.h.

◆ 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

◆ SubscriptExecSteps

◆ 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_SUBSCRIPTS 
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 49 of file execExpr.h.

50 {
51  /* entire expression has been evaluated completely, return */
52  EEOP_DONE,
53 
54  /* apply slot_getsomeattrs on corresponding tuple slot */
58 
59  /* compute non-system Var value */
63 
64  /* compute system Var value */
68 
69  /* compute wholerow Var */
71 
72  /*
73  * Compute non-system Var value, assign it into ExprState's resultslot.
74  * These are not used if a CheckVarSlotCompatibility() check would be
75  * needed.
76  */
80 
81  /* assign ExprState's resvalue/resnull to a column of its resultslot */
83  /* ditto, applying MakeExpandedObjectReadOnly() */
85 
86  /* evaluate Const value */
87  EEOP_CONST,
88 
89  /*
90  * Evaluate function call (including OpExprs etc). For speed, we
91  * distinguish in the opcode whether the function is strict and/or
92  * requires usage stats tracking.
93  */
98 
99  /*
100  * Evaluate boolean AND expression, one step per subexpression. FIRST/LAST
101  * subexpressions are special-cased for performance. Since AND always has
102  * at least two subexpressions, FIRST and LAST never apply to the same
103  * subexpression.
104  */
108 
109  /* similarly for boolean OR expression */
113 
114  /* evaluate boolean NOT expression */
116 
117  /* simplified version of BOOL_AND_STEP for use by ExecQual() */
118  EEOP_QUAL,
119 
120  /* unconditional jump to another step */
121  EEOP_JUMP,
122 
123  /* conditional jumps based on current result value */
127 
128  /* perform NULL tests for scalar values */
131 
132  /* perform NULL tests for row values */
135 
136  /* evaluate a BooleanTest expression */
141 
142  /* evaluate PARAM_EXEC/EXTERN parameters */
146 
147  /* return CaseTestExpr value */
149 
150  /* apply MakeExpandedObjectReadOnly() to target value */
152 
153  /* evaluate assorted special-purpose expression types */
157  EEOP_NULLIF,
163  EEOP_ROW,
164 
165  /*
166  * Compare two individual elements of each of two compared ROW()
167  * expressions. Skip to ROWCOMPARE_FINAL if elements are not equal.
168  */
170 
171  /* evaluate boolean value based on previous ROWCOMPARE_STEP operations */
173 
174  /* evaluate GREATEST() or LEAST() */
175  EEOP_MINMAX,
176 
177  /* evaluate FieldSelect expression */
179 
180  /*
181  * Deform tuple before evaluating new values for individual fields in a
182  * FieldStore expression.
183  */
185 
186  /*
187  * Form the new tuple for a FieldStore expression. Individual fields will
188  * have been evaluated into columns of the tuple deformed by the preceding
189  * DEFORM step.
190  */
192 
193  /* Process container subscripts; possibly short-circuit result to NULL */
195 
196  /*
197  * Compute old container element/slice when a SubscriptingRef assignment
198  * expression contains SubscriptingRef/FieldStore subexpressions. Value is
199  * accessed using the CaseTest mechanism.
200  */
202 
203  /* compute new value for SubscriptingRef assignment expression */
205 
206  /* compute element/slice for SubscriptingRef fetch expression */
208 
209  /* evaluate value for CoerceToDomainValue */
211 
212  /* evaluate a domain's NOT NULL constraint */
214 
215  /* evaluate a single domain CHECK constraint */
217 
218  /* evaluate assorted special-purpose expression types */
221  EEOP_XMLEXPR,
222  EEOP_AGGREF,
225  EEOP_SUBPLAN,
226 
227  /* aggregation related nodes */
241 
242  /* non-existent operation, used e.g. to check array lengths */
243  EEOP_LAST
244 } ExprEvalOp;
ExprEvalOp
Definition: execExpr.h:49

Function Documentation

◆ CheckExprStillValid()

void CheckExprStillValid ( ExprState state,
ExprContext econtext 
)

Definition at line 1773 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().

1774 {
1775  TupleTableSlot *innerslot;
1776  TupleTableSlot *outerslot;
1777  TupleTableSlot *scanslot;
1778 
1779  innerslot = econtext->ecxt_innertuple;
1780  outerslot = econtext->ecxt_outertuple;
1781  scanslot = econtext->ecxt_scantuple;
1782 
1783  for (int i = 0; i < state->steps_len; i++)
1784  {
1785  ExprEvalStep *op = &state->steps[i];
1786 
1787  switch (ExecEvalStepOp(state, op))
1788  {
1789  case EEOP_INNER_VAR:
1790  {
1791  int attnum = op->d.var.attnum;
1792 
1793  CheckVarSlotCompatibility(innerslot, attnum + 1, op->d.var.vartype);
1794  break;
1795  }
1796 
1797  case EEOP_OUTER_VAR:
1798  {
1799  int attnum = op->d.var.attnum;
1800 
1801  CheckVarSlotCompatibility(outerslot, attnum + 1, op->d.var.vartype);
1802  break;
1803  }
1804 
1805  case EEOP_SCAN_VAR:
1806  {
1807  int attnum = op->d.var.attnum;
1808 
1809  CheckVarSlotCompatibility(scanslot, attnum + 1, op->d.var.vartype);
1810  break;
1811  }
1812  default:
1813  break;
1814  }
1815  }
1816 }
struct ExprEvalStep * steps
Definition: execnodes.h:84
struct ExprEvalStep::@49::@51 var
static void CheckVarSlotCompatibility(TupleTableSlot *slot, int attnum, Oid vartype)
ExprEvalOp ExecEvalStepOp(ExprState *state, ExprEvalStep *op)
union ExprEvalStep::@49 d
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:227
int16 attnum
Definition: pg_attribute.h:83
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:229
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:225
int steps_len
Definition: execnodes.h:103
int i

◆ ExecAggInitGroup()

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

Definition at line 3896 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().

3898 {
3899  FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
3900  MemoryContext oldContext;
3901 
3902  /*
3903  * We must copy the datum into aggcontext if it is pass-by-ref. We do not
3904  * need to pfree the old transValue, since it's NULL. (We already checked
3905  * that the agg's input type is binary-compatible with its transtype, so
3906  * straight copy here is OK.)
3907  */
3908  oldContext = MemoryContextSwitchTo(aggcontext->ecxt_per_tuple_memory);
3909  pergroup->transValue = datumCopy(fcinfo->args[1].value,
3910  pertrans->transtypeByVal,
3911  pertrans->transtypeLen);
3912  pergroup->transValueIsNull = false;
3913  pergroup->noTransValue = false;
3914  MemoryContextSwitchTo(oldContext);
3915 }
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:233
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
FunctionCallInfo transfn_fcinfo
Definition: nodeAgg.h:162
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
Datum value
Definition: postgres.h:378
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 3924 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().

3927 {
3928  Assert(newValue != oldValue);
3929 
3930  if (!newValueIsNull)
3931  {
3933  if (DatumIsReadWriteExpandedObject(newValue,
3934  false,
3935  pertrans->transtypeLen) &&
3936  MemoryContextGetParent(DatumGetEOHP(newValue)->eoh_context) == CurrentMemoryContext)
3937  /* do nothing */ ;
3938  else
3939  newValue = datumCopy(newValue,
3940  pertrans->transtypeByVal,
3941  pertrans->transtypeLen);
3942  }
3943  else
3944  {
3945  /*
3946  * Ensure that AggStatePerGroup->transValue ends up being 0, so
3947  * callers can safely compare newValue/oldValue without having to
3948  * check their respective nullness.
3949  */
3950  newValue = (Datum) 0;
3951  }
3952 
3953  if (!oldValueIsNull)
3954  {
3955  if (DatumIsReadWriteExpandedObject(oldValue,
3956  false,
3957  pertrans->transtypeLen))
3958  DeleteExpandedObject(oldValue);
3959  else
3960  pfree(DatumGetPointer(oldValue));
3961  }
3962 
3963  return newValue;
3964 }
MemoryContext MemoryContextGetParent(MemoryContext context)
Definition: mcxt.c:440
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:233
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
void pfree(void *pointer)
Definition: mcxt.c:1057
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:131
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
ExprContext * curaggcontext
Definition: execnodes.h:2178
uintptr_t Datum
Definition: postgres.h:367
void DeleteExpandedObject(Datum d)
#define Assert(condition)
Definition: c.h:804
#define DatumIsReadWriteExpandedObject(d, isnull, typlen)
#define DatumGetPointer(X)
Definition: postgres.h:549

◆ ExecEvalAggOrderedTransDatum()

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

Definition at line 3970 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

3972 {
3973  AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
3974  int setno = op->d.agg_trans.setno;
3975 
3976  tuplesort_putdatum(pertrans->sortstates[setno],
3977  *op->resvalue, *op->resnull);
3978 }
void tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
Definition: tuplesort.c:1805
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
union ExprEvalStep::@49 d
Tuplesortstate ** sortstates
Definition: nodeAgg.h:154
struct ExprEvalStep::@49::@89 agg_trans

◆ ExecEvalAggOrderedTransTuple()

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

Definition at line 3984 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().

3986 {
3987  AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
3988  int setno = op->d.agg_trans.setno;
3989 
3990  ExecClearTuple(pertrans->sortslot);
3991  pertrans->sortslot->tts_nvalid = pertrans->numInputs;
3992  ExecStoreVirtualTuple(pertrans->sortslot);
3993  tuplesort_puttupleslot(pertrans->sortstates[setno], pertrans->sortslot);
3994 }
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
union ExprEvalStep::@49 d
Tuplesortstate ** sortstates
Definition: nodeAgg.h:154
struct ExprEvalStep::@49::@89 agg_trans
AttrNumber tts_nvalid
Definition: tuptable.h:121
TupleTableSlot * sortslot
Definition: nodeAgg.h:136
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522
void tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
Definition: tuplesort.c:1684

◆ ExecEvalArrayCoerce()

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

Definition at line 2798 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

2799 {
2800  Datum arraydatum;
2801 
2802  /* NULL array -> NULL result */
2803  if (*op->resnull)
2804  return;
2805 
2806  arraydatum = *op->resvalue;
2807 
2808  /*
2809  * If it's binary-compatible, modify the element type in the array header,
2810  * but otherwise leave the array as we received it.
2811  */
2812  if (op->d.arraycoerce.elemexprstate == NULL)
2813  {
2814  /* Detoast input array if necessary, and copy in any case */
2815  ArrayType *array = DatumGetArrayTypePCopy(arraydatum);
2816 
2817  ARR_ELEMTYPE(array) = op->d.arraycoerce.resultelemtype;
2818  *op->resvalue = PointerGetDatum(array);
2819  return;
2820  }
2821 
2822  /*
2823  * Use array_map to apply the sub-expression to each array element.
2824  */
2825  *op->resvalue = array_map(arraydatum,
2826  op->d.arraycoerce.elemexprstate,
2827  econtext,
2828  op->d.arraycoerce.resultelemtype,
2829  op->d.arraycoerce.amstate);
2830 }
Datum * resvalue
Definition: execExpr.h:257
#define PointerGetDatum(X)
Definition: postgres.h:556
bool * resnull
Definition: execExpr.h:258
union ExprEvalStep::@49 d
struct ExprEvalStep::@49::@69 arraycoerce
uintptr_t Datum
Definition: postgres.h:367
#define DatumGetArrayTypePCopy(X)
Definition: array.h:255
Datum array_map(Datum arrayd, ExprState *exprstate, ExprContext *econtext, Oid retType, ArrayMapState *amstate)
Definition: arrayfuncs.c:3158
#define ARR_ELEMTYPE(a)
Definition: array.h:285

◆ ExecEvalArrayExpr()

void ExecEvalArrayExpr ( ExprState state,
ExprEvalStep op 
)

Definition at line 2593 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().

2594 {
2595  ArrayType *result;
2596  Oid element_type = op->d.arrayexpr.elemtype;
2597  int nelems = op->d.arrayexpr.nelems;
2598  int ndims = 0;
2599  int dims[MAXDIM];
2600  int lbs[MAXDIM];
2601 
2602  /* Set non-null as default */
2603  *op->resnull = false;
2604 
2605  if (!op->d.arrayexpr.multidims)
2606  {
2607  /* Elements are presumably of scalar type */
2608  Datum *dvalues = op->d.arrayexpr.elemvalues;
2609  bool *dnulls = op->d.arrayexpr.elemnulls;
2610 
2611  /* setup for 1-D array of the given length */
2612  ndims = 1;
2613  dims[0] = nelems;
2614  lbs[0] = 1;
2615 
2616  result = construct_md_array(dvalues, dnulls, ndims, dims, lbs,
2617  element_type,
2618  op->d.arrayexpr.elemlength,
2619  op->d.arrayexpr.elembyval,
2620  op->d.arrayexpr.elemalign);
2621  }
2622  else
2623  {
2624  /* Must be nested array expressions */
2625  int nbytes = 0;
2626  int nitems = 0;
2627  int outer_nelems = 0;
2628  int elem_ndims = 0;
2629  int *elem_dims = NULL;
2630  int *elem_lbs = NULL;
2631  bool firstone = true;
2632  bool havenulls = false;
2633  bool haveempty = false;
2634  char **subdata;
2635  bits8 **subbitmaps;
2636  int *subbytes;
2637  int *subnitems;
2638  int32 dataoffset;
2639  char *dat;
2640  int iitem;
2641 
2642  subdata = (char **) palloc(nelems * sizeof(char *));
2643  subbitmaps = (bits8 **) palloc(nelems * sizeof(bits8 *));
2644  subbytes = (int *) palloc(nelems * sizeof(int));
2645  subnitems = (int *) palloc(nelems * sizeof(int));
2646 
2647  /* loop through and get data area from each element */
2648  for (int elemoff = 0; elemoff < nelems; elemoff++)
2649  {
2650  Datum arraydatum;
2651  bool eisnull;
2652  ArrayType *array;
2653  int this_ndims;
2654 
2655  arraydatum = op->d.arrayexpr.elemvalues[elemoff];
2656  eisnull = op->d.arrayexpr.elemnulls[elemoff];
2657 
2658  /* temporarily ignore null subarrays */
2659  if (eisnull)
2660  {
2661  haveempty = true;
2662  continue;
2663  }
2664 
2665  array = DatumGetArrayTypeP(arraydatum);
2666 
2667  /* run-time double-check on element type */
2668  if (element_type != ARR_ELEMTYPE(array))
2669  ereport(ERROR,
2670  (errcode(ERRCODE_DATATYPE_MISMATCH),
2671  errmsg("cannot merge incompatible arrays"),
2672  errdetail("Array with element type %s cannot be "
2673  "included in ARRAY construct with element type %s.",
2674  format_type_be(ARR_ELEMTYPE(array)),
2675  format_type_be(element_type))));
2676 
2677  this_ndims = ARR_NDIM(array);
2678  /* temporarily ignore zero-dimensional subarrays */
2679  if (this_ndims <= 0)
2680  {
2681  haveempty = true;
2682  continue;
2683  }
2684 
2685  if (firstone)
2686  {
2687  /* Get sub-array details from first member */
2688  elem_ndims = this_ndims;
2689  ndims = elem_ndims + 1;
2690  if (ndims <= 0 || ndims > MAXDIM)
2691  ereport(ERROR,
2692  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
2693  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
2694  ndims, MAXDIM)));
2695 
2696  elem_dims = (int *) palloc(elem_ndims * sizeof(int));
2697  memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int));
2698  elem_lbs = (int *) palloc(elem_ndims * sizeof(int));
2699  memcpy(elem_lbs, ARR_LBOUND(array), elem_ndims * sizeof(int));
2700 
2701  firstone = false;
2702  }
2703  else
2704  {
2705  /* Check other sub-arrays are compatible */
2706  if (elem_ndims != this_ndims ||
2707  memcmp(elem_dims, ARR_DIMS(array),
2708  elem_ndims * sizeof(int)) != 0 ||
2709  memcmp(elem_lbs, ARR_LBOUND(array),
2710  elem_ndims * sizeof(int)) != 0)
2711  ereport(ERROR,
2712  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2713  errmsg("multidimensional arrays must have array "
2714  "expressions with matching dimensions")));
2715  }
2716 
2717  subdata[outer_nelems] = ARR_DATA_PTR(array);
2718  subbitmaps[outer_nelems] = ARR_NULLBITMAP(array);
2719  subbytes[outer_nelems] = ARR_SIZE(array) - ARR_DATA_OFFSET(array);
2720  nbytes += subbytes[outer_nelems];
2721  subnitems[outer_nelems] = ArrayGetNItems(this_ndims,
2722  ARR_DIMS(array));
2723  nitems += subnitems[outer_nelems];
2724  havenulls |= ARR_HASNULL(array);
2725  outer_nelems++;
2726  }
2727 
2728  /*
2729  * If all items were null or empty arrays, return an empty array;
2730  * otherwise, if some were and some weren't, raise error. (Note: we
2731  * must special-case this somehow to avoid trying to generate a 1-D
2732  * array formed from empty arrays. It's not ideal...)
2733  */
2734  if (haveempty)
2735  {
2736  if (ndims == 0) /* didn't find any nonempty array */
2737  {
2738  *op->resvalue = PointerGetDatum(construct_empty_array(element_type));
2739  return;
2740  }
2741  ereport(ERROR,
2742  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2743  errmsg("multidimensional arrays must have array "
2744  "expressions with matching dimensions")));
2745  }
2746 
2747  /* setup for multi-D array */
2748  dims[0] = outer_nelems;
2749  lbs[0] = 1;
2750  for (int i = 1; i < ndims; i++)
2751  {
2752  dims[i] = elem_dims[i - 1];
2753  lbs[i] = elem_lbs[i - 1];
2754  }
2755 
2756  if (havenulls)
2757  {
2758  dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
2759  nbytes += dataoffset;
2760  }
2761  else
2762  {
2763  dataoffset = 0; /* marker for no null bitmap */
2764  nbytes += ARR_OVERHEAD_NONULLS(ndims);
2765  }
2766 
2767  result = (ArrayType *) palloc(nbytes);
2768  SET_VARSIZE(result, nbytes);
2769  result->ndim = ndims;
2770  result->dataoffset = dataoffset;
2771  result->elemtype = element_type;
2772  memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
2773  memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
2774 
2775  dat = ARR_DATA_PTR(result);
2776  iitem = 0;
2777  for (int i = 0; i < outer_nelems; i++)
2778  {
2779  memcpy(dat, subdata[i], subbytes[i]);
2780  dat += subbytes[i];
2781  if (havenulls)
2782  array_bitmap_copy(ARR_NULLBITMAP(result), iitem,
2783  subbitmaps[i], 0,
2784  subnitems[i]);
2785  iitem += subnitems[i];
2786  }
2787  }
2788 
2789  *op->resvalue = PointerGetDatum(result);
2790 }
#define ARR_OVERHEAD_NONULLS(ndims)
Definition: array.h:303
#define ARR_SIZE(a)
Definition: array.h:282
Datum * resvalue
Definition: execExpr.h:257
#define PointerGetDatum(X)
Definition: postgres.h:556
void array_bitmap_copy(bits8 *destbitmap, int destoffset, const bits8 *srcbitmap, int srcoffset, int nitems)
Definition: arrayfuncs.c:4719
int32 dataoffset
Definition: array.h:89
bool * resnull
Definition: execExpr.h:258
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:75
int errcode(int sqlerrcode)
Definition: elog.c:694
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
ArrayType * construct_empty_array(Oid elmtype)
Definition: arrayfuncs.c:3437
unsigned int Oid
Definition: postgres_ext.h:31
#define ARR_OVERHEAD_WITHNULLS(ndims, nitems)
Definition: array.h:305
signed int int32
Definition: c.h:429
#define ARR_DATA_OFFSET(a)
Definition: array.h:309
#define ARR_LBOUND(a)
Definition: array.h:289
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
Oid elemtype
Definition: array.h:90
#define ARR_DIMS(a)
Definition: array.h:287
#define ARR_DATA_PTR(a)
Definition: array.h:315
#define MAXDIM
Definition: array.h:75
int errdetail(const char *fmt,...)
Definition: elog.c:1038
#define ARR_HASNULL(a)
Definition: array.h:284
uint8 bits8
Definition: c.h:448
uintptr_t Datum
Definition: postgres.h:367
#define ereport(elevel,...)
Definition: elog.h:155
#define ARR_NDIM(a)
Definition: array.h:283
struct ExprEvalStep::@49::@68 arrayexpr
void * palloc(Size size)
Definition: mcxt.c:950
int errmsg(const char *fmt,...)
Definition: elog.c:905
int i
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:329
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:3353
#define ARR_ELEMTYPE(a)
Definition: array.h:285
#define ARR_NULLBITMAP(a)
Definition: array.h:293
int ndim
Definition: array.h:88
#define DatumGetArrayTypeP(X)
Definition: array.h:254

◆ ExecEvalConstraintCheck()

void ExecEvalConstraintCheck ( ExprState state,
ExprEvalStep op 
)

Definition at line 3366 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

3367 {
3368  if (!*op->d.domaincheck.checknull &&
3369  !DatumGetBool(*op->d.domaincheck.checkvalue))
3370  ereport(ERROR,
3371  (errcode(ERRCODE_CHECK_VIOLATION),
3372  errmsg("value for domain %s violates check constraint \"%s\"",
3373  format_type_be(op->d.domaincheck.resulttype),
3374  op->d.domaincheck.constraintname),
3375  errdomainconstraint(op->d.domaincheck.resulttype,
3376  op->d.domaincheck.constraintname)));
3377 }
int errcode(int sqlerrcode)
Definition: elog.c:694
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
#define ERROR
Definition: elog.h:45
int errdomainconstraint(Oid datatypeOid, const char *conname)
Definition: domains.c:384
union ExprEvalStep::@49 d
#define DatumGetBool(X)
Definition: postgres.h:393
struct ExprEvalStep::@49::@78 domaincheck
#define ereport(elevel,...)
Definition: elog.h:155
int errmsg(const char *fmt,...)
Definition: elog.c:905

◆ ExecEvalConstraintNotNull()

void ExecEvalConstraintNotNull ( ExprState state,
ExprEvalStep op 
)

Definition at line 3352 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

3353 {
3354  if (*op->resnull)
3355  ereport(ERROR,
3356  (errcode(ERRCODE_NOT_NULL_VIOLATION),
3357  errmsg("domain %s does not allow null values",
3358  format_type_be(op->d.domaincheck.resulttype)),
3359  errdatatype(op->d.domaincheck.resulttype)));
3360 }
bool * resnull
Definition: execExpr.h:258
int errcode(int sqlerrcode)
Definition: elog.c:694
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
struct ExprEvalStep::@49::@78 domaincheck
int errdatatype(Oid datatypeOid)
Definition: domains.c:360
#define ereport(elevel,...)
Definition: elog.h:155
int errmsg(const char *fmt,...)
Definition: elog.c:905

◆ ExecEvalConvertRowtype()

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

Definition at line 3104 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().

3105 {
3107  HeapTuple result;
3108  Datum tupDatum;
3109  HeapTupleHeader tuple;
3110  HeapTupleData tmptup;
3111  TupleDesc indesc,
3112  outdesc;
3113 
3114  /* NULL in -> NULL out */
3115  if (*op->resnull)
3116  return;
3117 
3118  tupDatum = *op->resvalue;
3119  tuple = DatumGetHeapTupleHeader(tupDatum);
3120 
3121  /* Lookup tupdescs if first time through or after rescan */
3122  if (op->d.convert_rowtype.indesc == NULL)
3123  {
3124  get_cached_rowtype(exprType((Node *) convert->arg), -1,
3125  &op->d.convert_rowtype.indesc,
3126  econtext);
3127  op->d.convert_rowtype.initialized = false;
3128  }
3129  if (op->d.convert_rowtype.outdesc == NULL)
3130  {
3131  get_cached_rowtype(convert->resulttype, -1,
3132  &op->d.convert_rowtype.outdesc,
3133  econtext);
3134  op->d.convert_rowtype.initialized = false;
3135  }
3136 
3137  indesc = op->d.convert_rowtype.indesc;
3138  outdesc = op->d.convert_rowtype.outdesc;
3139 
3140  /*
3141  * We used to be able to assert that incoming tuples are marked with
3142  * exactly the rowtype of indesc. However, now that ExecEvalWholeRowVar
3143  * might change the tuples' marking to plain RECORD due to inserting
3144  * aliases, we can only make this weak test:
3145  */
3146  Assert(HeapTupleHeaderGetTypeId(tuple) == indesc->tdtypeid ||
3147  HeapTupleHeaderGetTypeId(tuple) == RECORDOID);
3148 
3149  /* if first time through, initialize conversion map */
3150  if (!op->d.convert_rowtype.initialized)
3151  {
3152  MemoryContext old_cxt;
3153 
3154  /* allocate map in long-lived memory context */
3155  old_cxt = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
3156 
3157  /* prepare map from old to new attribute numbers */
3158  op->d.convert_rowtype.map = convert_tuples_by_name(indesc, outdesc);
3159  op->d.convert_rowtype.initialized = true;
3160 
3161  MemoryContextSwitchTo(old_cxt);
3162  }
3163 
3164  /* Following steps need a HeapTuple not a bare HeapTupleHeader */
3165  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
3166  tmptup.t_data = tuple;
3167 
3168  if (op->d.convert_rowtype.map != NULL)
3169  {
3170  /* Full conversion with attribute rearrangement needed */
3171  result = execute_attr_map_tuple(&tmptup, op->d.convert_rowtype.map);
3172  /* Result already has appropriate composite-datum header fields */
3173  *op->resvalue = HeapTupleGetDatum(result);
3174  }
3175  else
3176  {
3177  /*
3178  * The tuple is physically compatible as-is, but we need to insert the
3179  * destination rowtype OID in its composite-datum header field, so we
3180  * have to copy it anyway. heap_copy_tuple_as_datum() is convenient
3181  * for this since it will both make the physical copy and insert the
3182  * correct composite header fields. Note that we aren't expecting to
3183  * have to flatten any toasted fields: the input was a composite
3184  * datum, so it shouldn't contain any. So heap_copy_tuple_as_datum()
3185  * is overkill here, but its check for external fields is cheap.
3186  */
3187  *op->resvalue = heap_copy_tuple_as_datum(&tmptup, outdesc);
3188  }
3189 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
Definition: nodes.h:533
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:295
HeapTupleHeader t_data
Definition: htup.h:68
static void convert(const int32 val, char *const buf)
Definition: zic.c:1990
union ExprEvalStep::@49 d
uint32 t_len
Definition: htup.h:64
struct ExprEvalStep::@49::@79 convert_rowtype
TupleConversionMap * convert_tuples_by_name(TupleDesc indesc, TupleDesc outdesc)
Definition: tupconvert.c:102
HeapTuple execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map)
Definition: tupconvert.c:139
Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc)
Definition: heaptuple.c:984
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod, TupleDesc *cache_field, ExprContext *econtext)
uintptr_t Datum
Definition: postgres.h:367
#define HeapTupleHeaderGetTypeId(tup)
Definition: htup_details.h:458
#define Assert(condition)
Definition: c.h:804
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:232
Oid tdtypeid
Definition: tupdesc.h:82
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecEvalCurrentOfExpr()

void ExecEvalCurrentOfExpr ( ExprState state,
ExprEvalStep op 
)

Definition at line 2453 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

2454 {
2455  ereport(ERROR,
2456  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2457  errmsg("WHERE CURRENT OF is not supported for this table type")));
2458 }
int errcode(int sqlerrcode)
Definition: elog.c:694
#define ERROR
Definition: elog.h:45
#define ereport(elevel,...)
Definition: elog.h:155
int errmsg(const char *fmt,...)
Definition: elog.c:905

◆ ExecEvalFieldSelect()

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

Definition at line 2912 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().

2913 {
2914  AttrNumber fieldnum = op->d.fieldselect.fieldnum;
2915  Datum tupDatum;
2916  HeapTupleHeader tuple;
2917  Oid tupType;
2918  int32 tupTypmod;
2919  TupleDesc tupDesc;
2920  Form_pg_attribute attr;
2921  HeapTupleData tmptup;
2922 
2923  /* NULL record -> NULL result */
2924  if (*op->resnull)
2925  return;
2926 
2927  tupDatum = *op->resvalue;
2928 
2929  /* We can special-case expanded records for speed */
2931  {
2933 
2934  Assert(erh->er_magic == ER_MAGIC);
2935 
2936  /* Extract record's TupleDesc */
2937  tupDesc = expanded_record_get_tupdesc(erh);
2938 
2939  /*
2940  * Find field's attr record. Note we don't support system columns
2941  * here: a datum tuple doesn't have valid values for most of the
2942  * interesting system columns anyway.
2943  */
2944  if (fieldnum <= 0) /* should never happen */
2945  elog(ERROR, "unsupported reference to system column %d in FieldSelect",
2946  fieldnum);
2947  if (fieldnum > tupDesc->natts) /* should never happen */
2948  elog(ERROR, "attribute number %d exceeds number of columns %d",
2949  fieldnum, tupDesc->natts);
2950  attr = TupleDescAttr(tupDesc, fieldnum - 1);
2951 
2952  /* Check for dropped column, and force a NULL result if so */
2953  if (attr->attisdropped)
2954  {
2955  *op->resnull = true;
2956  return;
2957  }
2958 
2959  /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
2960  /* As in CheckVarSlotCompatibility, we should but can't check typmod */
2961  if (op->d.fieldselect.resulttype != attr->atttypid)
2962  ereport(ERROR,
2963  (errcode(ERRCODE_DATATYPE_MISMATCH),
2964  errmsg("attribute %d has wrong type", fieldnum),
2965  errdetail("Table has type %s, but query expects %s.",
2966  format_type_be(attr->atttypid),
2967  format_type_be(op->d.fieldselect.resulttype))));
2968 
2969  /* extract the field */
2970  *op->resvalue = expanded_record_get_field(erh, fieldnum,
2971  op->resnull);
2972  }
2973  else
2974  {
2975  /* Get the composite datum and extract its type fields */
2976  tuple = DatumGetHeapTupleHeader(tupDatum);
2977 
2978  tupType = HeapTupleHeaderGetTypeId(tuple);
2979  tupTypmod = HeapTupleHeaderGetTypMod(tuple);
2980 
2981  /* Lookup tupdesc if first time through or if type changes */
2982  tupDesc = get_cached_rowtype(tupType, tupTypmod,
2983  &op->d.fieldselect.argdesc,
2984  econtext);
2985 
2986  /*
2987  * Find field's attr record. Note we don't support system columns
2988  * here: a datum tuple doesn't have valid values for most of the
2989  * interesting system columns anyway.
2990  */
2991  if (fieldnum <= 0) /* should never happen */
2992  elog(ERROR, "unsupported reference to system column %d in FieldSelect",
2993  fieldnum);
2994  if (fieldnum > tupDesc->natts) /* should never happen */
2995  elog(ERROR, "attribute number %d exceeds number of columns %d",
2996  fieldnum, tupDesc->natts);
2997  attr = TupleDescAttr(tupDesc, fieldnum - 1);
2998 
2999  /* Check for dropped column, and force a NULL result if so */
3000  if (attr->attisdropped)
3001  {
3002  *op->resnull = true;
3003  return;
3004  }
3005 
3006  /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
3007  /* As in CheckVarSlotCompatibility, we should but can't check typmod */
3008  if (op->d.fieldselect.resulttype != attr->atttypid)
3009  ereport(ERROR,
3010  (errcode(ERRCODE_DATATYPE_MISMATCH),
3011  errmsg("attribute %d has wrong type", fieldnum),
3012  errdetail("Table has type %s, but query expects %s.",
3013  format_type_be(attr->atttypid),
3014  format_type_be(op->d.fieldselect.resulttype))));
3015 
3016  /* heap_getattr needs a HeapTuple not a bare HeapTupleHeader */
3017  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
3018  tmptup.t_data = tuple;
3019 
3020  /* extract the field */
3021  *op->resvalue = heap_getattr(&tmptup,
3022  fieldnum,
3023  tupDesc,
3024  op->resnull);
3025  }
3026 }
#define VARATT_IS_EXTERNAL_EXPANDED(PTR)
Definition: postgres.h:322
Datum * resvalue
Definition: execExpr.h:257
static Datum expanded_record_get_field(ExpandedRecordHeader *erh, int fnumber, bool *isnull)
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
bool * resnull
Definition: execExpr.h:258
int errcode(int sqlerrcode)
Definition: elog.c:694
struct ExprEvalStep::@49::@74 fieldselect
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
unsigned int Oid
Definition: postgres_ext.h:31
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:295
signed int int32
Definition: c.h:429
HeapTupleHeader t_data
Definition: htup.h:68
#define HeapTupleHeaderGetTypMod(tup)
Definition: htup_details.h:468
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
uint32 t_len
Definition: htup.h:64
int errdetail(const char *fmt,...)
Definition: elog.c:1038
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:197
static TupleDesc expanded_record_get_tupdesc(ExpandedRecordHeader *erh)
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
#define heap_getattr(tup, attnum, tupleDesc, isnull)
Definition: htup_details.h:762
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod, TupleDesc *cache_field, ExprContext *econtext)
uintptr_t Datum
Definition: postgres.h:367
#define ER_MAGIC
#define HeapTupleHeaderGetTypeId(tup)
Definition: htup_details.h:458
#define ereport(elevel,...)
Definition: elog.h:155
#define Assert(condition)
Definition: c.h:804
#define DatumGetPointer(X)
Definition: postgres.h:549
int errmsg(const char *fmt,...)
Definition: elog.c:905
#define elog(elevel,...)
Definition: elog.h:227
int16 AttrNumber
Definition: attnum.h:21
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecEvalFieldStoreDeForm()

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

Definition at line 3038 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().

3039 {
3040  TupleDesc tupDesc;
3041 
3042  /* Lookup tupdesc if first time through or after rescan */
3043  tupDesc = get_cached_rowtype(op->d.fieldstore.fstore->resulttype, -1,
3044  op->d.fieldstore.argdesc, econtext);
3045 
3046  /* Check that current tupdesc doesn't have more fields than we allocated */
3047  if (unlikely(tupDesc->natts > op->d.fieldstore.ncolumns))
3048  elog(ERROR, "too many columns in composite type %u",
3049  op->d.fieldstore.fstore->resulttype);
3050 
3051  if (*op->resnull)
3052  {
3053  /* Convert null input tuple into an all-nulls row */
3054  memset(op->d.fieldstore.nulls, true,
3055  op->d.fieldstore.ncolumns * sizeof(bool));
3056  }
3057  else
3058  {
3059  /*
3060  * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader. We
3061  * set all the fields in the struct just in case.
3062  */
3063  Datum tupDatum = *op->resvalue;
3064  HeapTupleHeader tuphdr;
3065  HeapTupleData tmptup;
3066 
3067  tuphdr = DatumGetHeapTupleHeader(tupDatum);
3068  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
3069  ItemPointerSetInvalid(&(tmptup.t_self));
3070  tmptup.t_tableOid = InvalidOid;
3071  tmptup.t_data = tuphdr;
3072 
3073  heap_deform_tuple(&tmptup, tupDesc,
3074  op->d.fieldstore.values,
3075  op->d.fieldstore.nulls);
3076  }
3077 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:295
HeapTupleHeader t_data
Definition: htup.h:68
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
ItemPointerData t_self
Definition: htup.h:65
uint32 t_len
Definition: htup.h:64
Oid t_tableOid
Definition: htup.h:66
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod, TupleDesc *cache_field, ExprContext *econtext)
struct ExprEvalStep::@49::@75 fieldstore
uintptr_t Datum
Definition: postgres.h:367
#define InvalidOid
Definition: postgres_ext.h:36
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
#define ItemPointerSetInvalid(pointer)
Definition: itemptr.h:172
#define elog(elevel,...)
Definition: elog.h:227
#define unlikely(x)
Definition: c.h:273
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecEvalFieldStoreForm()

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

Definition at line 3084 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

3085 {
3086  HeapTuple tuple;
3087 
3088  /* argdesc should already be valid from the DeForm step */
3089  tuple = heap_form_tuple(*op->d.fieldstore.argdesc,
3090  op->d.fieldstore.values,
3091  op->d.fieldstore.nulls);
3092 
3093  *op->resvalue = HeapTupleGetDatum(tuple);
3094  *op->resnull = false;
3095 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
union ExprEvalStep::@49 d
struct ExprEvalStep::@49::@75 fieldstore
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221

◆ ExecEvalFuncExprFusage()

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

Definition at line 2264 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().

2266 {
2267  FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
2268  PgStat_FunctionCallUsage fcusage;
2269  Datum d;
2270 
2271  pgstat_init_function_usage(fcinfo, &fcusage);
2272 
2273  fcinfo->isnull = false;
2274  d = op->d.func.fn_addr(fcinfo);
2275  *op->resvalue = d;
2276  *op->resnull = fcinfo->isnull;
2277 
2278  pgstat_end_function_usage(&fcusage, true);
2279 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
Definition: pgstat.c:1855
union ExprEvalStep::@49 d
uintptr_t Datum
Definition: postgres.h:367
struct ExprEvalStep::@49::@56 func
void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
Definition: pgstat.c:1926

◆ ExecEvalFuncExprStrictFusage()

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

Definition at line 2285 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().

2287 {
2288 
2289  FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
2290  PgStat_FunctionCallUsage fcusage;
2291  NullableDatum *args = fcinfo->args;
2292  int nargs = op->d.func.nargs;
2293  Datum d;
2294 
2295  /* strict function, so check for NULL args */
2296  for (int argno = 0; argno < nargs; argno++)
2297  {
2298  if (args[argno].isnull)
2299  {
2300  *op->resnull = true;
2301  return;
2302  }
2303  }
2304 
2305  pgstat_init_function_usage(fcinfo, &fcusage);
2306 
2307  fcinfo->isnull = false;
2308  d = op->d.func.fn_addr(fcinfo);
2309  *op->resvalue = d;
2310  *op->resnull = fcinfo->isnull;
2311 
2312  pgstat_end_function_usage(&fcusage, true);
2313 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
Definition: pgstat.c:1855
union ExprEvalStep::@49 d
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
uintptr_t Datum
Definition: postgres.h:367
struct ExprEvalStep::@49::@56 func
void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
Definition: pgstat.c:1926

◆ ExecEvalGroupingFunc()

void ExecEvalGroupingFunc ( ExprState state,
ExprEvalStep op 
)

Definition at line 3605 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().

3606 {
3607  AggState *aggstate = castNode(AggState, state->parent);
3608  int result = 0;
3609  Bitmapset *grouped_cols = aggstate->grouped_cols;
3610  ListCell *lc;
3611 
3612  foreach(lc, op->d.grouping_func.clauses)
3613  {
3614  int attnum = lfirst_int(lc);
3615 
3616  result <<= 1;
3617 
3618  if (!bms_is_member(attnum, grouped_cols))
3619  result |= 1;
3620  }
3621 
3622  *op->resvalue = Int32GetDatum(result);
3623  *op->resnull = false;
3624 }
struct PlanState * parent
Definition: execnodes.h:107
Datum * resvalue
Definition: execExpr.h:257
#define castNode(_type_, nodeptr)
Definition: nodes.h:602
bool * resnull
Definition: execExpr.h:258
union ExprEvalStep::@49 d
#define lfirst_int(lc)
Definition: pg_list.h:170
Bitmapset * grouped_cols
Definition: execnodes.h:2187
int16 attnum
Definition: pg_attribute.h:83
#define Int32GetDatum(X)
Definition: postgres.h:479
struct ExprEvalStep::@49::@83 grouping_func
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:427

◆ ExecEvalMinMax()

void ExecEvalMinMax ( ExprState state,
ExprEvalStep op 
)

Definition at line 2859 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().

2860 {
2861  Datum *values = op->d.minmax.values;
2862  bool *nulls = op->d.minmax.nulls;
2863  FunctionCallInfo fcinfo = op->d.minmax.fcinfo_data;
2864  MinMaxOp operator = op->d.minmax.op;
2865 
2866  /* set at initialization */
2867  Assert(fcinfo->args[0].isnull == false);
2868  Assert(fcinfo->args[1].isnull == false);
2869 
2870  /* default to null result */
2871  *op->resnull = true;
2872 
2873  for (int off = 0; off < op->d.minmax.nelems; off++)
2874  {
2875  /* ignore NULL inputs */
2876  if (nulls[off])
2877  continue;
2878 
2879  if (*op->resnull)
2880  {
2881  /* first nonnull input, adopt value */
2882  *op->resvalue = values[off];
2883  *op->resnull = false;
2884  }
2885  else
2886  {
2887  int cmpresult;
2888 
2889  /* apply comparison function */
2890  fcinfo->args[0].value = *op->resvalue;
2891  fcinfo->args[1].value = values[off];
2892 
2893  fcinfo->isnull = false;
2894  cmpresult = DatumGetInt32(FunctionCallInvoke(fcinfo));
2895  if (fcinfo->isnull) /* probably should not happen */
2896  continue;
2897 
2898  if (cmpresult > 0 && operator == IS_LEAST)
2899  *op->resvalue = values[off];
2900  else if (cmpresult < 0 && operator == IS_GREATEST)
2901  *op->resvalue = values[off];
2902  }
2903  }
2904 }
Datum * resvalue
Definition: execExpr.h:257
#define DatumGetInt32(X)
Definition: postgres.h:472
bool * resnull
Definition: execExpr.h:258
MinMaxOp
Definition: primnodes.h:1117
union ExprEvalStep::@49 d
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
#define FunctionCallInvoke(fcinfo)
Definition: fmgr.h:172
Datum value
Definition: postgres.h:378
uintptr_t Datum
Definition: postgres.h:367
#define Assert(condition)
Definition: c.h:804
static Datum values[MAXATTR]
Definition: bootstrap.c:165
struct ExprEvalStep::@49::@73 minmax

◆ ExecEvalNextValueExpr()

void ExecEvalNextValueExpr ( ExprState state,
ExprEvalStep op 
)

Definition at line 2464 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().

2465 {
2466  int64 newval = nextval_internal(op->d.nextvalueexpr.seqid, false);
2467 
2468  switch (op->d.nextvalueexpr.seqtypid)
2469  {
2470  case INT2OID:
2471  *op->resvalue = Int16GetDatum((int16) newval);
2472  break;
2473  case INT4OID:
2474  *op->resvalue = Int32GetDatum((int32) newval);
2475  break;
2476  case INT8OID:
2477  *op->resvalue = Int64GetDatum((int64) newval);
2478  break;
2479  default:
2480  elog(ERROR, "unsupported sequence type %u",
2481  op->d.nextvalueexpr.seqtypid);
2482  }
2483  *op->resnull = false;
2484 }
signed short int16
Definition: c.h:428
Datum * resvalue
Definition: execExpr.h:257
int64 nextval_internal(Oid relid, bool check_permissions)
Definition: sequence.c:579
bool * resnull
Definition: execExpr.h:258
#define Int16GetDatum(X)
Definition: postgres.h:451
struct ExprEvalStep::@49::@67 nextvalueexpr
signed int int32
Definition: c.h:429
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1700
#define newval
#define Int32GetDatum(X)
Definition: postgres.h:479
#define elog(elevel,...)
Definition: elog.h:227

◆ ExecEvalParamExec()

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

Definition at line 2322 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().

2323 {
2324  ParamExecData *prm;
2325 
2326  prm = &(econtext->ecxt_param_exec_vals[op->d.param.paramid]);
2327  if (unlikely(prm->execPlan != NULL))
2328  {
2329  /* Parameter not evaluated yet, so go do it */
2330  ExecSetParamPlan(prm->execPlan, econtext);
2331  /* ExecSetParamPlan should have processed this param... */
2332  Assert(prm->execPlan == NULL);
2333  }
2334  *op->resvalue = prm->value;
2335  *op->resnull = prm->isnull;
2336 }
void * execPlan
Definition: params.h:148
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
union ExprEvalStep::@49 d
void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
Definition: nodeSubplan.c:1058
bool isnull
Definition: params.h:150
struct ExprEvalStep::@49::@61 param
ParamExecData * ecxt_param_exec_vals
Definition: execnodes.h:236
#define Assert(condition)
Definition: c.h:804
Datum value
Definition: params.h:149
#define unlikely(x)
Definition: c.h:273

◆ ExecEvalParamExtern()

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

Definition at line 2344 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().

2345 {
2346  ParamListInfo paramInfo = econtext->ecxt_param_list_info;
2347  int paramId = op->d.param.paramid;
2348 
2349  if (likely(paramInfo &&
2350  paramId > 0 && paramId <= paramInfo->numParams))
2351  {
2352  ParamExternData *prm;
2353  ParamExternData prmdata;
2354 
2355  /* give hook a chance in case parameter is dynamic */
2356  if (paramInfo->paramFetch != NULL)
2357  prm = paramInfo->paramFetch(paramInfo, paramId, false, &prmdata);
2358  else
2359  prm = &paramInfo->params[paramId - 1];
2360 
2361  if (likely(OidIsValid(prm->ptype)))
2362  {
2363  /* safety check in case hook did something unexpected */
2364  if (unlikely(prm->ptype != op->d.param.paramtype))
2365  ereport(ERROR,
2366  (errcode(ERRCODE_DATATYPE_MISMATCH),
2367  errmsg("type of parameter %d (%s) does not match that when preparing the plan (%s)",
2368  paramId,
2369  format_type_be(prm->ptype),
2370  format_type_be(op->d.param.paramtype))));
2371  *op->resvalue = prm->value;
2372  *op->resnull = prm->isnull;
2373  return;
2374  }
2375  }
2376 
2377  ereport(ERROR,
2378  (errcode(ERRCODE_UNDEFINED_OBJECT),
2379  errmsg("no value found for parameter %d", paramId)));
2380 }
ParamExternData params[FLEXIBLE_ARRAY_MEMBER]
Definition: params.h:125
Datum value
Definition: params.h:92
#define likely(x)
Definition: c.h:272
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
int errcode(int sqlerrcode)
Definition: elog.c:694
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
#define OidIsValid(objectId)
Definition: c.h:710
ParamFetchHook paramFetch
Definition: params.h:112
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
struct ExprEvalStep::@49::@61 param
#define ereport(elevel,...)
Definition: elog.h:155
int errmsg(const char *fmt,...)
Definition: elog.c:905
#define unlikely(x)
Definition: c.h:273
ParamListInfo ecxt_param_list_info
Definition: execnodes.h:237
bool isnull
Definition: params.h:93

◆ ExecEvalRow()

void ExecEvalRow ( ExprState state,
ExprEvalStep op 
)

Definition at line 2839 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

2840 {
2841  HeapTuple tuple;
2842 
2843  /* build tuple from evaluated field values */
2844  tuple = heap_form_tuple(op->d.row.tupdesc,
2845  op->d.row.elemvalues,
2846  op->d.row.elemnulls);
2847 
2848  *op->resvalue = HeapTupleGetDatum(tuple);
2849  *op->resnull = false;
2850 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
union ExprEvalStep::@49 d
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221
struct ExprEvalStep::@49::@70 row

◆ ExecEvalRowNotNull()

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

Definition at line 2499 of file execExprInterp.c.

References ExecEvalRowNullInt().

Referenced by ExecInterpExpr().

2500 {
2501  ExecEvalRowNullInt(state, op, econtext, false);
2502 }
static void ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op, ExprContext *econtext, bool checkisnull)

◆ ExecEvalRowNull()

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

Definition at line 2490 of file execExprInterp.c.

References ExecEvalRowNullInt().

Referenced by ExecInterpExpr().

2491 {
2492  ExecEvalRowNullInt(state, op, econtext, true);
2493 }
static void ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op, ExprContext *econtext, bool checkisnull)

◆ ExecEvalScalarArrayOp()

void ExecEvalScalarArrayOp ( ExprState state,
ExprEvalStep op 
)

Definition at line 3202 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().

3203 {
3204  FunctionCallInfo fcinfo = op->d.scalararrayop.fcinfo_data;
3205  bool useOr = op->d.scalararrayop.useOr;
3206  bool strictfunc = op->d.scalararrayop.finfo->fn_strict;
3207  ArrayType *arr;
3208  int nitems;
3209  Datum result;
3210  bool resultnull;
3211  int16 typlen;
3212  bool typbyval;
3213  char typalign;
3214  char *s;
3215  bits8 *bitmap;
3216  int bitmask;
3217 
3218  /*
3219  * If the array is NULL then we return NULL --- it's not very meaningful
3220  * to do anything else, even if the operator isn't strict.
3221  */
3222  if (*op->resnull)
3223  return;
3224 
3225  /* Else okay to fetch and detoast the array */
3226  arr = DatumGetArrayTypeP(*op->resvalue);
3227 
3228  /*
3229  * If the array is empty, we return either FALSE or TRUE per the useOr
3230  * flag. This is correct even if the scalar is NULL; since we would
3231  * evaluate the operator zero times, it matters not whether it would want
3232  * to return NULL.
3233  */
3234  nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
3235  if (nitems <= 0)
3236  {
3237  *op->resvalue = BoolGetDatum(!useOr);
3238  *op->resnull = false;
3239  return;
3240  }
3241 
3242  /*
3243  * If the scalar is NULL, and the function is strict, return NULL; no
3244  * point in iterating the loop.
3245  */
3246  if (fcinfo->args[0].isnull && strictfunc)
3247  {
3248  *op->resnull = true;
3249  return;
3250  }
3251 
3252  /*
3253  * We arrange to look up info about the element type only once per series
3254  * of calls, assuming the element type doesn't change underneath us.
3255  */
3256  if (op->d.scalararrayop.element_type != ARR_ELEMTYPE(arr))
3257  {
3259  &op->d.scalararrayop.typlen,
3260  &op->d.scalararrayop.typbyval,
3261  &op->d.scalararrayop.typalign);
3262  op->d.scalararrayop.element_type = ARR_ELEMTYPE(arr);
3263  }
3264 
3265  typlen = op->d.scalararrayop.typlen;
3266  typbyval = op->d.scalararrayop.typbyval;
3267  typalign = op->d.scalararrayop.typalign;
3268 
3269  /* Initialize result appropriately depending on useOr */
3270  result = BoolGetDatum(!useOr);
3271  resultnull = false;
3272 
3273  /* Loop over the array elements */
3274  s = (char *) ARR_DATA_PTR(arr);
3275  bitmap = ARR_NULLBITMAP(arr);
3276  bitmask = 1;
3277 
3278  for (int i = 0; i < nitems; i++)
3279  {
3280  Datum elt;
3281  Datum thisresult;
3282 
3283  /* Get array element, checking for NULL */
3284  if (bitmap && (*bitmap & bitmask) == 0)
3285  {
3286  fcinfo->args[1].value = (Datum) 0;
3287  fcinfo->args[1].isnull = true;
3288  }
3289  else
3290  {
3291  elt = fetch_att(s, typbyval, typlen);
3292  s = att_addlength_pointer(s, typlen, s);
3293  s = (char *) att_align_nominal(s, typalign);
3294  fcinfo->args[1].value = elt;
3295  fcinfo->args[1].isnull = false;
3296  }
3297 
3298  /* Call comparison function */
3299  if (fcinfo->args[1].isnull && strictfunc)
3300  {
3301  fcinfo->isnull = true;
3302  thisresult = (Datum) 0;
3303  }
3304  else
3305  {
3306  fcinfo->isnull = false;
3307  thisresult = op->d.scalararrayop.fn_addr(fcinfo);
3308  }
3309 
3310  /* Combine results per OR or AND semantics */
3311  if (fcinfo->isnull)
3312  resultnull = true;
3313  else if (useOr)
3314  {
3315  if (DatumGetBool(thisresult))
3316  {
3317  result = BoolGetDatum(true);
3318  resultnull = false;
3319  break; /* needn't look at any more elements */
3320  }
3321  }
3322  else
3323  {
3324  if (!DatumGetBool(thisresult))
3325  {
3326  result = BoolGetDatum(false);
3327  resultnull = false;
3328  break; /* needn't look at any more elements */
3329  }
3330  }
3331 
3332  /* advance bitmap pointer if any */
3333  if (bitmap)
3334  {
3335  bitmask <<= 1;
3336  if (bitmask == 0x100)
3337  {
3338  bitmap++;
3339  bitmask = 1;
3340  }
3341  }
3342  }
3343 
3344  *op->resvalue = result;
3345  *op->resnull = resultnull;
3346 }
signed short int16
Definition: c.h:428
struct ExprEvalStep::@49::@80 scalararrayop
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:148
Datum * resvalue
Definition: execExpr.h:257
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2218
bool * resnull
Definition: execExpr.h:258
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:75
char typalign
Definition: pg_type.h:176
union ExprEvalStep::@49 d
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
#define ARR_DIMS(a)
Definition: array.h:287
#define ARR_DATA_PTR(a)
Definition: array.h:315
#define DatumGetBool(X)
Definition: postgres.h:393
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:176
Datum value
Definition: postgres.h:378
uint8 bits8
Definition: c.h:448
uintptr_t Datum
Definition: postgres.h:367
#define BoolGetDatum(X)
Definition: postgres.h:402
#define ARR_NDIM(a)
Definition: array.h:283
#define fetch_att(T, attbyval, attlen)
Definition: tupmacs.h:75
int i
#define ARR_ELEMTYPE(a)
Definition: array.h:285
#define ARR_NULLBITMAP(a)
Definition: array.h:293
#define DatumGetArrayTypeP(X)
Definition: array.h:254

◆ ExecEvalSQLValueFunction()

void ExecEvalSQLValueFunction ( ExprState state,
ExprEvalStep op 
)

Definition at line 2386 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().

2387 {
2388  LOCAL_FCINFO(fcinfo, 0);
2389  SQLValueFunction *svf = op->d.sqlvaluefunction.svf;
2390 
2391  *op->resnull = false;
2392 
2393  /*
2394  * Note: current_schema() can return NULL. current_user() etc currently
2395  * cannot, but might as well code those cases the same way for safety.
2396  */
2397  switch (svf->op)
2398  {
2399  case SVFOP_CURRENT_DATE:
2401  break;
2402  case SVFOP_CURRENT_TIME:
2403  case SVFOP_CURRENT_TIME_N:
2405  break;
2409  break;
2410  case SVFOP_LOCALTIME:
2411  case SVFOP_LOCALTIME_N:
2413  break;
2414  case SVFOP_LOCALTIMESTAMP:
2417  break;
2418  case SVFOP_CURRENT_ROLE:
2419  case SVFOP_CURRENT_USER:
2420  case SVFOP_USER:
2421  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2422  *op->resvalue = current_user(fcinfo);
2423  *op->resnull = fcinfo->isnull;
2424  break;
2425  case SVFOP_SESSION_USER:
2426  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2427  *op->resvalue = session_user(fcinfo);
2428  *op->resnull = fcinfo->isnull;
2429  break;
2430  case SVFOP_CURRENT_CATALOG:
2431  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2432  *op->resvalue = current_database(fcinfo);
2433  *op->resnull = fcinfo->isnull;
2434  break;
2435  case SVFOP_CURRENT_SCHEMA:
2436  InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
2437  *op->resvalue = current_schema(fcinfo);
2438  *op->resnull = fcinfo->isnull;
2439  break;
2440  }
2441 }
Datum current_schema(PG_FUNCTION_ARGS)
Definition: name.c:279
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
#define TimeTzADTPGetDatum(X)
Definition: date.h:59
TimestampTz GetSQLCurrentTimestamp(int32 typmod)
Definition: timestamp.c:1596
#define DateADTGetDatum(X)
Definition: date.h:57
DateADT GetSQLCurrentDate(void)
Definition: date.c:300
SQLValueFunctionOp op
Definition: primnodes.h:1167
Datum current_database(PG_FUNCTION_ARGS)
Definition: misc.c:172
union ExprEvalStep::@49 d
#define TimestampTzGetDatum(X)
Definition: timestamp.h:32
TimeTzADT * GetSQLCurrentTime(int32 typmod)
Definition: date.c:333
Datum current_user(PG_FUNCTION_ARGS)
Definition: name.c:263
#define TimestampGetDatum(X)
Definition: timestamp.h:31
TimeADT GetSQLLocalTime(int32 typmod)
Definition: date.c:353
Datum session_user(PG_FUNCTION_ARGS)
Definition: name.c:269
#define TimeADTGetDatum(X)
Definition: date.h:58
Timestamp GetSQLLocalTimestamp(int32 typmod)
Definition: timestamp.c:1610
#define InvalidOid
Definition: postgres_ext.h:36
#define LOCAL_FCINFO(name, nargs)
Definition: fmgr.h:110
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:150
struct ExprEvalStep::@49::@66 sqlvaluefunction

◆ ExecEvalStepOp()

ExprEvalOp ExecEvalStepOp ( ExprState state,
ExprEvalStep op 
)

Definition at line 2234 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().

2235 {
2236 #if defined(EEO_USE_COMPUTED_GOTO)
2237  if (state->flags & EEO_FLAG_DIRECT_THREADED)
2238  {
2239  ExprEvalOpLookup key;
2240  ExprEvalOpLookup *res;
2241 
2242  key.opcode = (void *) op->opcode;
2243  res = bsearch(&key,
2244  reverse_dispatch_table,
2245  EEOP_LAST /* nmembers */ ,
2246  sizeof(ExprEvalOpLookup),
2247  dispatch_compare_ptr);
2248  Assert(res); /* unknown ops shouldn't get looked up */
2249  return res->op;
2250  }
2251 #endif
2252  return (ExprEvalOp) op->opcode;
2253 }
ExprEvalOp
Definition: execExpr.h:49
#define Assert(condition)
Definition: c.h:804
intptr_t opcode
Definition: execExpr.h:254
uint8 flags
Definition: execnodes.h:64
#define EEO_FLAG_DIRECT_THREADED
Definition: execExpr.h:28

◆ ExecEvalSubPlan()

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

Definition at line 3630 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

3631 {
3632  SubPlanState *sstate = op->d.subplan.sstate;
3633 
3634  /* could potentially be nested, so make sure there's enough stack */
3636 
3637  *op->resvalue = ExecSubPlan(sstate, econtext, op->resnull);
3638 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
union ExprEvalStep::@49 d
struct ExprEvalStep::@49::@85 subplan
void check_stack_depth(void)
Definition: postgres.c:3310
Datum ExecSubPlan(SubPlanState *node, ExprContext *econtext, bool *isNull)
Definition: nodeSubplan.c:62

◆ ExecEvalSysVar()

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

Definition at line 3876 of file execExprInterp.c.

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

Referenced by ExecInterpExpr().

3878 {
3879  Datum d;
3880 
3881  /* slot_getsysattr has sufficient defenses against bad attnums */
3882  d = slot_getsysattr(slot,
3883  op->d.var.attnum,
3884  op->resnull);
3885  *op->resvalue = d;
3886  /* this ought to be unreachable, but it's cheap enough to check */
3887  if (unlikely(*op->resnull))
3888  elog(ERROR, "failed to fetch attribute from slot");
3889 }
Datum * resvalue
Definition: execExpr.h:257
bool * resnull
Definition: execExpr.h:258
struct ExprEvalStep::@49::@51 var
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
uintptr_t Datum
Definition: postgres.h:367
#define elog(elevel,...)
Definition: elog.h:227
#define unlikely(x)
Definition: c.h:273
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 3647 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().

3648 {
3649  Var *variable = op->d.wholerow.var;
3650  TupleTableSlot *slot;
3651  TupleDesc output_tupdesc;
3652  MemoryContext oldcontext;
3653  HeapTupleHeader dtuple;
3654  HeapTuple tuple;
3655 
3656  /* This was checked by ExecInitExpr */
3657  Assert(variable->varattno == InvalidAttrNumber);
3658 
3659  /* Get the input slot we want */
3660  switch (variable->varno)
3661  {
3662  case INNER_VAR:
3663  /* get the tuple from the inner node */
3664  slot = econtext->ecxt_innertuple;
3665  break;
3666 
3667  case OUTER_VAR:
3668  /* get the tuple from the outer node */
3669  slot = econtext->ecxt_outertuple;
3670  break;
3671 
3672  /* INDEX_VAR is handled by default case */
3673 
3674  default:
3675  /* get the tuple from the relation being scanned */
3676  slot = econtext->ecxt_scantuple;
3677  break;
3678  }
3679 
3680  /* Apply the junkfilter if any */
3681  if (op->d.wholerow.junkFilter != NULL)
3682  slot = ExecFilterJunk(op->d.wholerow.junkFilter, slot);
3683 
3684  /*
3685  * If first time through, obtain tuple descriptor and check compatibility.
3686  *
3687  * XXX: It'd be great if this could be moved to the expression
3688  * initialization phase, but due to using slots that's currently not
3689  * feasible.
3690  */
3691  if (op->d.wholerow.first)
3692  {
3693  /* optimistically assume we don't need slow path */
3694  op->d.wholerow.slow = false;
3695 
3696  /*
3697  * If the Var identifies a named composite type, we must check that
3698  * the actual tuple type is compatible with it.
3699  */
3700  if (variable->vartype != RECORDOID)
3701  {
3702  TupleDesc var_tupdesc;
3703  TupleDesc slot_tupdesc;
3704 
3705  /*
3706  * We really only care about numbers of attributes and data types.
3707  * Also, we can ignore type mismatch on columns that are dropped
3708  * in the destination type, so long as (1) the physical storage
3709  * matches or (2) the actual column value is NULL. Case (1) is
3710  * helpful in some cases involving out-of-date cached plans, while
3711  * case (2) is expected behavior in situations such as an INSERT
3712  * into a table with dropped columns (the planner typically
3713  * generates an INT4 NULL regardless of the dropped column type).
3714  * If we find a dropped column and cannot verify that case (1)
3715  * holds, we have to use the slow path to check (2) for each row.
3716  *
3717  * If vartype is a domain over composite, just look through that
3718  * to the base composite type.
3719  */
3720  var_tupdesc = lookup_rowtype_tupdesc_domain(variable->vartype,
3721  -1, false);
3722 
3723  slot_tupdesc = slot->tts_tupleDescriptor;
3724 
3725  if (var_tupdesc->natts != slot_tupdesc->natts)
3726  ereport(ERROR,
3727  (errcode(ERRCODE_DATATYPE_MISMATCH),
3728  errmsg("table row type and query-specified row type do not match"),
3729  errdetail_plural("Table row contains %d attribute, but query expects %d.",
3730  "Table row contains %d attributes, but query expects %d.",
3731  slot_tupdesc->natts,
3732  slot_tupdesc->natts,
3733  var_tupdesc->natts)));
3734 
3735  for (int i = 0; i < var_tupdesc->natts; i++)
3736  {
3737  Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
3738  Form_pg_attribute sattr = TupleDescAttr(slot_tupdesc, i);
3739 
3740  if (vattr->atttypid == sattr->atttypid)
3741  continue; /* no worries */
3742  if (!vattr->attisdropped)
3743  ereport(ERROR,
3744  (errcode(ERRCODE_DATATYPE_MISMATCH),
3745  errmsg("table row type and query-specified row type do not match"),
3746  errdetail("Table has type %s at ordinal position %d, but query expects %s.",
3747  format_type_be(sattr->atttypid),
3748  i + 1,
3749  format_type_be(vattr->atttypid))));
3750 
3751  if (vattr->attlen != sattr->attlen ||
3752  vattr->attalign != sattr->attalign)
3753  op->d.wholerow.slow = true; /* need to check for nulls */
3754  }
3755 
3756  /*
3757  * Use the variable's declared rowtype as the descriptor for the
3758  * output values, modulo possibly assigning new column names
3759  * below. In particular, we *must* absorb any attisdropped
3760  * markings.
3761  */
3762  oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
3763  output_tupdesc = CreateTupleDescCopy(var_tupdesc);
3764  MemoryContextSwitchTo(oldcontext);
3765 
3766  ReleaseTupleDesc(var_tupdesc);
3767  }
3768  else
3769  {
3770  /*
3771  * In the RECORD case, we use the input slot's rowtype as the
3772  * descriptor for the output values, modulo possibly assigning new
3773  * column names below.
3774  */
3775  oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
3776  output_tupdesc = CreateTupleDescCopy(slot->tts_tupleDescriptor);
3777  MemoryContextSwitchTo(oldcontext);
3778  }
3779 
3780  /*
3781  * Construct a tuple descriptor for the composite values we'll
3782  * produce, and make sure its record type is "blessed". The main
3783  * reason to do this is to be sure that operations such as
3784  * row_to_json() will see the desired column names when they look up
3785  * the descriptor from the type information embedded in the composite
3786  * values.
3787  *
3788  * We already got the correct physical datatype info above, but now we
3789  * should try to find the source RTE and adopt its column aliases, in
3790  * case they are different from the original rowtype's names. For
3791  * example, in "SELECT foo(t) FROM tab t(x,y)", the first two columns
3792  * in the composite output should be named "x" and "y" regardless of
3793  * tab's column names.
3794  *
3795  * If we can't locate the RTE, assume the column names we've got are
3796  * OK. (As of this writing, the only cases where we can't locate the
3797  * RTE are in execution of trigger WHEN clauses, and then the Var will
3798  * have the trigger's relation's rowtype, so its names are fine.)
3799  * Also, if the creator of the RTE didn't bother to fill in an eref
3800  * field, assume our column names are OK. (This happens in COPY, and
3801  * perhaps other places.)
3802  */
3803  if (econtext->ecxt_estate &&
3804  variable->varno <= econtext->ecxt_estate->es_range_table_size)
3805  {
3806  RangeTblEntry *rte = exec_rt_fetch(variable->varno,
3807  econtext->ecxt_estate);
3808 
3809  if (rte->eref)
3810  ExecTypeSetColNames(output_tupdesc, rte->eref->colnames);
3811  }
3812 
3813  /* Bless the tupdesc if needed, and save it in the execution state */
3814  op->d.wholerow.tupdesc = BlessTupleDesc(output_tupdesc);
3815 
3816  op->d.wholerow.first = false;
3817  }
3818 
3819  /*
3820  * Make sure all columns of the slot are accessible in the slot's
3821  * Datum/isnull arrays.
3822  */
3823  slot_getallattrs(slot);
3824 
3825  if (op->d.wholerow.slow)
3826  {
3827  /* Check to see if any dropped attributes are non-null */
3828  TupleDesc tupleDesc = slot->tts_tupleDescriptor;
3829  TupleDesc var_tupdesc = op->d.wholerow.tupdesc;
3830 
3831  Assert(var_tupdesc->natts == tupleDesc->natts);
3832 
3833  for (int i = 0; i < var_tupdesc->natts; i++)
3834  {
3835  Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
3836  Form_pg_attribute sattr = TupleDescAttr(tupleDesc, i);
3837 
3838  if (!vattr->attisdropped)
3839  continue; /* already checked non-dropped cols */
3840  if (slot->tts_isnull[i])
3841  continue; /* null is always okay */
3842  if (vattr->attlen != sattr->attlen ||
3843  vattr->attalign != sattr->attalign)
3844  ereport(ERROR,
3845  (errcode(ERRCODE_DATATYPE_MISMATCH),
3846  errmsg("table row type and query-specified row type do not match"),
3847  errdetail("Physical storage mismatch on dropped attribute at ordinal position %d.",
3848  i + 1)));
3849  }
3850  }
3851 
3852  /*
3853  * Build a composite datum, making sure any toasted fields get detoasted.
3854  *
3855  * (Note: it is critical that we not change the slot's state here.)
3856  */
3858  slot->tts_values,
3859  slot->tts_isnull);
3860  dtuple = tuple->t_data;
3861 
3862  /*
3863  * Label the datum with the composite type info we identified before.
3864  *
3865  * (Note: we could skip doing this by passing op->d.wholerow.tupdesc to
3866  * the tuple build step; but that seems a tad risky so let's not.)
3867  */
3868  HeapTupleHeaderSetTypeId(dtuple, op->d.wholerow.tupdesc->tdtypeid);
3869  HeapTupleHeaderSetTypMod(dtuple, op->d.wholerow.tupdesc->tdtypmod);
3870 
3871  *op->resvalue = PointerGetDatum(dtuple);
3872  *op->resnull = false;
3873 }
struct ExprEvalStep::@49::@52 wholerow
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:110
#define HeapTupleHeaderSetTypeId(tup, typeid)
Definition: htup_details.h:463
Datum * resvalue
Definition: execExpr.h:257
List * colnames
Definition: primnodes.h:43
#define PointerGetDatum(X)
Definition: postgres.h:556
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
bool * resnull
Definition: execExpr.h:258
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
int errcode(int sqlerrcode)
Definition: elog.c:694
AttrNumber varattno
Definition: primnodes.h:186
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
Datum * tts_values
Definition: tuptable.h:126
Definition: primnodes.h:181
TupleDesc lookup_rowtype_tupdesc_domain(Oid type_id, int32 typmod, bool noError)
Definition: typcache.c:1882
HeapTupleHeader t_data
Definition: htup.h:68
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
Oid vartype
Definition: primnodes.h:188
static void slot_getallattrs(TupleTableSlot *slot)
Definition: tuptable.h:354
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2052
HeapTuple toast_build_flattened_tuple(TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptoast.c:563
bool * tts_isnull
Definition: tuptable.h:128
int errdetail(const char *fmt,...)
Definition: elog.c:1038
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:227
struct EState * ecxt_estate
Definition: execnodes.h:261
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition: executor.h:547
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:197
Index varno
Definition: primnodes.h:184
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
TupleTableSlot * ExecFilterJunk(JunkFilter *junkfilter, TupleTableSlot *slot)
Definition: execJunk.c:287
#define HeapTupleHeaderSetTypMod(tup, typmod)
Definition: htup_details.h:473
#define ereport(elevel,...)
Definition: elog.h:155
#define INNER_VAR
Definition: primnodes.h:171
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:229
#define Assert(condition)
Definition: c.h:804
int errdetail_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1130
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:225
Index es_range_table_size
Definition: execnodes.h:533
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:232
#define InvalidAttrNumber
Definition: attnum.h:23
int errmsg(const char *fmt,...)
Definition: elog.c:905
int i
Alias * eref
Definition: parsenodes.h:1120
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122
#define OUTER_VAR
Definition: primnodes.h:172
void ExecTypeSetColNames(TupleDesc typeInfo, List *namesList)
Definition: execTuples.c:2006

◆ ExecEvalXmlExpr()

void ExecEvalXmlExpr ( ExprState state,
ExprEvalStep op 
)

Definition at line 3386 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().

3387 {
3388  XmlExpr *xexpr = op->d.xmlexpr.xexpr;
3389  Datum value;
3390 
3391  *op->resnull = true; /* until we get a result */
3392  *op->resvalue = (Datum) 0;
3393 
3394  switch (xexpr->op)
3395  {
3396  case IS_XMLCONCAT:
3397  {
3398  Datum *argvalue = op->d.xmlexpr.argvalue;
3399  bool *argnull = op->d.xmlexpr.argnull;
3400  List *values = NIL;
3401 
3402  for (int i = 0; i < list_length(xexpr->args); i++)
3403  {
3404  if (!argnull[i])
3405  values = lappend(values, DatumGetPointer(argvalue[i]));
3406  }
3407 
3408  if (values != NIL)
3409  {
3410  *op->resvalue = PointerGetDatum(xmlconcat(values));
3411  *op->resnull = false;
3412  }
3413  }
3414  break;
3415 
3416  case IS_XMLFOREST:
3417  {
3418  Datum *argvalue = op->d.xmlexpr.named_argvalue;
3419  bool *argnull = op->d.xmlexpr.named_argnull;
3421  ListCell *lc;
3422  ListCell *lc2;
3423  int i;
3424 
3425  initStringInfo(&buf);
3426 
3427  i = 0;
3428  forboth(lc, xexpr->named_args, lc2, xexpr->arg_names)
3429  {
3430  Expr *e = (Expr *) lfirst(lc);
3431  char *argname = strVal(lfirst(lc2));
3432 
3433  if (!argnull[i])
3434  {
3435  value = argvalue[i];
3436  appendStringInfo(&buf, "<%s>%s</%s>",
3437  argname,
3439  exprType((Node *) e), true),
3440  argname);
3441  *op->resnull = false;
3442  }
3443  i++;
3444  }
3445 
3446  if (!*op->resnull)
3447  {
3448  text *result;
3449 
3450  result = cstring_to_text_with_len(buf.data, buf.len);
3451  *op->resvalue = PointerGetDatum(result);
3452  }
3453 
3454  pfree(buf.data);
3455  }
3456  break;
3457 
3458  case IS_XMLELEMENT:
3459  *op->resvalue = PointerGetDatum(xmlelement(xexpr,
3460  op->d.xmlexpr.named_argvalue,
3461  op->d.xmlexpr.named_argnull,
3462  op->d.xmlexpr.argvalue,
3463  op->d.xmlexpr.argnull));
3464  *op->resnull = false;
3465  break;
3466 
3467  case IS_XMLPARSE:
3468  {
3469  Datum *argvalue = op->d.xmlexpr.argvalue;
3470  bool *argnull = op->d.xmlexpr.argnull;
3471  text *data;
3472  bool preserve_whitespace;
3473 
3474  /* arguments are known to be text, bool */
3475  Assert(list_length(xexpr->args) == 2);
3476 
3477  if (argnull[0])
3478  return;
3479  value = argvalue[0];
3480  data = DatumGetTextPP(value);
3481 
3482  if (argnull[1]) /* probably can't happen */
3483  return;
3484  value = argvalue[1];
3485  preserve_whitespace = DatumGetBool(value);
3486 
3487  *op->resvalue = PointerGetDatum(xmlparse(data,
3488  xexpr->xmloption,
3489  preserve_whitespace));
3490  *op->resnull = false;
3491  }
3492  break;
3493 
3494  case IS_XMLPI:
3495  {
3496  text *arg;
3497  bool isnull;
3498 
3499  /* optional argument is known to be text */
3500  Assert(list_length(xexpr->args) <= 1);
3501 
3502  if (xexpr->args)
3503  {
3504  isnull = op->d.xmlexpr.argnull[0];
3505  if (isnull)
3506  arg = NULL;
3507  else
3508  arg = DatumGetTextPP(op->d.xmlexpr.argvalue[0]);
3509  }
3510  else
3511  {
3512  arg = NULL;
3513  isnull = false;
3514  }
3515 
3516  *op->resvalue = PointerGetDatum(xmlpi(xexpr->name,
3517  arg,
3518  isnull,
3519  op->resnull));
3520  }
3521  break;
3522 
3523  case IS_XMLROOT:
3524  {
3525  Datum *argvalue = op->d.xmlexpr.argvalue;
3526  bool *argnull = op->d.xmlexpr.argnull;
3527  xmltype *data;
3528  text *version;
3529  int standalone;
3530 
3531  /* arguments are known to be xml, text, int */
3532  Assert(list_length(xexpr->args) == 3);
3533 
3534  if (argnull[0])
3535  return;
3536  data = DatumGetXmlP(argvalue[0]);
3537 
3538  if (argnull[1])
3539  version = NULL;
3540  else
3541  version = DatumGetTextPP(argvalue[1]);
3542 
3543  Assert(!argnull[2]); /* always present */
3544  standalone = DatumGetInt32(argvalue[2]);
3545 
3546  *op->resvalue = PointerGetDatum(xmlroot(data,
3547  version,
3548  standalone));
3549  *op->resnull = false;
3550  }
3551  break;
3552 
3553  case IS_XMLSERIALIZE:
3554  {
3555  Datum *argvalue = op->d.xmlexpr.argvalue;
3556  bool *argnull = op->d.xmlexpr.argnull;
3557 
3558  /* argument type is known to be xml */
3559  Assert(list_length(xexpr->args) == 1);
3560 
3561  if (argnull[0])
3562  return;
3563  value = argvalue[0];
3564 
3566  xexpr->xmloption));
3567  *op->resnull = false;
3568  }
3569  break;
3570 
3571  case IS_DOCUMENT:
3572  {
3573  Datum *argvalue = op->d.xmlexpr.argvalue;
3574  bool *argnull = op->d.xmlexpr.argnull;
3575 
3576  /* optional argument is known to be xml */
3577  Assert(list_length(xexpr->args) == 1);
3578 
3579  if (argnull[0])
3580  return;
3581  value = argvalue[0];
3582 
3583  *op->resvalue =
3585  *op->resnull = false;
3586  }
3587  break;
3588 
3589  default:
3590  elog(ERROR, "unrecognized XML operation");
3591  break;
3592  }
3593 }
#define NIL
Definition: pg_list.h:65
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:446
char * name
Definition: primnodes.h:1206
Datum * resvalue
Definition: execExpr.h:257
#define DatumGetInt32(X)
Definition: postgres.h:472
#define PointerGetDatum(X)
Definition: postgres.h:556
#define DatumGetTextPP(X)
Definition: fmgr.h:292
bool * resnull
Definition: execExpr.h:258
xmltype * xmlconcat(List *args)
Definition: xml.c:512
Definition: nodes.h:533
#define strVal(v)
Definition: value.h:54
List * arg_names
Definition: primnodes.h:1208
#define DatumGetXmlP(X)
Definition: xml.h:50
xmltype * xmlpi(const char *target, text *arg, bool arg_is_null, bool *result_is_null)
Definition: xml.c:770
static struct @141 value
void pfree(void *pointer)
Definition: mcxt.c:1057
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
#define ERROR
Definition: elog.h:45
union ExprEvalStep::@49 d
text * xmltotext_with_xmloption(xmltype *data, XmlOptionType xmloption_arg)
Definition: xml.c:615
static char * buf
Definition: pg_test_fsync.c:68
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:201
xmltype * xmlroot(xmltype *data, text *version, int standalone)
Definition: xml.c:822
#define DatumGetBool(X)
Definition: postgres.h:393
List * lappend(List *list, void *datum)
Definition: list.c:336
bool xml_is_document(xmltype *arg)
Definition: xml.c:888
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
XmlExprOp op
Definition: primnodes.h:1205
uintptr_t Datum
Definition: postgres.h:367
#define BoolGetDatum(X)
Definition: postgres.h:402
List * named_args
Definition: primnodes.h:1207
List * args
Definition: primnodes.h:1209
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
XmlOptionType xmloption
Definition: primnodes.h:1210
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
static int list_length(const List *l)
Definition: pg_list.h:149
#define DatumGetPointer(X)
Definition: postgres.h:549
static Datum values[MAXATTR]
Definition: bootstrap.c:165
e
Definition: preproc-init.c:82
#define elog(elevel,...)
Definition: elog.h:227
int i
xmltype * xmlelement(XmlExpr *xexpr, Datum *named_argvalue, bool *named_argnull, Datum *argvalue, bool *argnull)
Definition: xml.c:628
void * arg
Definition: c.h:621
char * map_sql_value_to_xml_value(Datum value, Oid type, bool xml_escape_strings)
Definition: xml.c:2134
struct ExprEvalStep::@49::@81 xmlexpr
Definition: pg_list.h:50
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 1753 of file execExprInterp.c.

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

Referenced by ExecReadyInterpretedExpr().

1754 {
1755  /*
1756  * First time through, check whether attribute matches Var. Might not be
1757  * ok anymore, due to schema changes.
1758  */
1759  CheckExprStillValid(state, econtext);
1760 
1761  /* skip the check during further executions */
1762  state->evalfunc = (ExprStateEvalFunc) state->evalfunc_private;
1763 
1764  /* and actually execute */
1765  return state->evalfunc(state, econtext, isNull);
1766 }
Datum(* ExprStateEvalFunc)(struct ExprState *expression, struct ExprContext *econtext, bool *isNull)
Definition: execnodes.h:52
ExprStateEvalFunc evalfunc
Definition: execnodes.h:90
void * evalfunc_private
Definition: execnodes.h:96
void CheckExprStillValid(ExprState *state, ExprContext *econtext)

◆ 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 */
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  */
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  */
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  */
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  {
301  return;
302  }
303  else if (step0 == EEOP_ASSIGN_OUTER_VAR)
304  {
306  return;
307  }
308  else if (step0 == EEOP_ASSIGN_SCAN_VAR)
309  {
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 
329 #endif /* EEO_USE_COMPUTED_GOTO */
330 
331  state->evalfunc_private = (void *) ExecInterpExpr;
332 }
Datum ExecInterpExprStillValid(ExprState *state, ExprContext *econtext, bool *isNull)
static Datum ExecJustOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
static Datum ExecJustScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
static Datum ExecJustInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
struct ExprEvalStep * steps
Definition: execnodes.h:84
ExprEvalOp
Definition: execExpr.h:49
static Datum ExecJustConst(ExprState *state, ExprContext *econtext, bool *isnull)
union ExprEvalStep::@49 d
ExprStateEvalFunc evalfunc
Definition: execnodes.h:90
static Datum ExecJustInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
static Datum ExecJustAssignOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
void * evalfunc_private
Definition: execnodes.h:96
static Datum ExecJustApplyFuncToCase(ExprState *state, ExprContext *econtext, bool *isnull)
static Datum ExecJustAssignOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
struct ExprEvalStep::@49::@63 casetest
static Datum ExecJustScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
static Datum ExecJustAssignScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
#define Assert(condition)
Definition: c.h:804
intptr_t opcode
Definition: execExpr.h:254
static Datum ExecJustAssignScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
static void ExecInitInterpreter(void)
static Datum ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
static Datum ExecJustOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
int steps_len
Definition: execnodes.h:103
static Datum ExecJustAssignInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
static Datum ExecJustAssignInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
uint8 flags
Definition: execnodes.h:64
#define EEO_OPCODE(opcode)
#define EEO_FLAG_INTERPRETER_INITIALIZED
Definition: execExpr.h:26
#define EEO_FLAG_DIRECT_THREADED
Definition: execExpr.h:28

◆ ExprEvalPushStep()

void ExprEvalPushStep ( ExprState es,
const ExprEvalStep s 
)

Definition at line 2105 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().

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