1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/*-------------------------------------------------------------------------
*
* params.h
* Support for finding the values associated with Param nodes.
*
*
* Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* src/include/nodes/params.h
*
*-------------------------------------------------------------------------
*/
#ifndef PARAMS_H
#define PARAMS_H
/* Forward declarations, to avoid including other headers */
struct Bitmapset;
struct ExprState;
struct Param;
struct ParseState;
/*
* ParamListInfo
*
* ParamListInfo structures are used to pass parameters into the executor
* for parameterized plans. We support two basic approaches to supplying
* parameter values, the "static" way and the "dynamic" way.
*
* In the static approach, per-parameter data is stored in an array of
* ParamExternData structs appended to the ParamListInfo struct.
* Each entry in the array defines the value to be substituted for a
* PARAM_EXTERN parameter. The "paramid" of a PARAM_EXTERN Param
* can range from 1 to numParams.
*
* Although parameter numbers are normally consecutive, we allow
* ptype == InvalidOid to signal an unused array entry.
*
* pflags is a flags field. Currently the only used bit is:
* PARAM_FLAG_CONST signals the planner that it may treat this parameter
* as a constant (i.e., generate a plan that works only for this value
* of the parameter).
*
* In the dynamic approach, all access to parameter values is done through
* hook functions found in the ParamListInfo struct. In this case,
* the ParamExternData array is typically unused and not allocated;
* but the legal range of paramid is still 1 to numParams.
*
* Although the data structure is really an array, not a list, we keep
* the old typedef name to avoid unnecessary code changes.
*
* There are 3 hook functions that can be associated with a ParamListInfo
* structure:
*
* If paramFetch isn't null, it is called to fetch the ParamExternData
* for a particular param ID, rather than accessing the relevant element
* of the ParamExternData array. This supports the case where the array
* isn't there at all, as well as cases where the data in the array
* might be obsolete or lazily evaluated. paramFetch must return the
* address of a ParamExternData struct describing the specified param ID;
* the convention above about ptype == InvalidOid signaling an invalid
* param ID still applies. The returned struct can either be placed in
* the "workspace" supplied by the caller, or it can be in storage
* controlled by the paramFetch hook if that's more convenient.
* (In either case, the struct is not expected to be long-lived.)
* If "speculative" is true, the paramFetch hook should not risk errors
* in trying to fetch the parameter value, and should report an invalid
* parameter instead.
*
* If paramCompile isn't null, then it controls what execExpr.c compiles
* for PARAM_EXTERN Param nodes --- typically, this hook would emit a
* EEOP_PARAM_CALLBACK step. This allows unnecessary work to be
* optimized away in compiled expressions.
*
* If parserSetup isn't null, then it is called to re-instantiate the
* original parsing hooks when a query needs to be re-parsed/planned.
* This is especially useful if the types of parameters might change
* from time to time, since it can replace the need to supply a fixed
* list of parameter types to the parser.
*
* Notice that the paramFetch and paramCompile hooks are actually passed
* the ParamListInfo struct's address; they can therefore access all
* three of the "arg" fields, and the distinction between paramFetchArg
* and paramCompileArg is rather arbitrary.
*/
#define PARAM_FLAG_CONST 0x0001 /* parameter is constant */
typedef struct ParamExternData
{
Datum value; /* parameter value */
bool isnull; /* is it NULL? */
uint16 pflags; /* flag bits, see above */
Oid ptype; /* parameter's datatype, or 0 */
} ParamExternData;
typedef struct ParamListInfoData *ParamListInfo;
typedef ParamExternData *(*ParamFetchHook) (ParamListInfo params,
int paramid, bool speculative,
ParamExternData *workspace);
typedef void (*ParamCompileHook) (ParamListInfo params, struct Param *param,
struct ExprState *state,
Datum *resv, bool *resnull);
typedef void (*ParserSetupHook) (struct ParseState *pstate, void *arg);
typedef struct ParamListInfoData
{
ParamFetchHook paramFetch; /* parameter fetch hook */
void *paramFetchArg;
ParamCompileHook paramCompile; /* parameter compile hook */
void *paramCompileArg;
ParserSetupHook parserSetup; /* parser setup hook */
void *parserSetupArg;
char *paramValuesStr; /* params as a single string for errors */
int numParams; /* nominal/maximum # of Params represented */
/*
* params[] may be of length zero if paramFetch is supplied; otherwise it
* must be of length numParams.
*/
ParamExternData params[FLEXIBLE_ARRAY_MEMBER];
} ParamListInfoData;
/* ----------------
* ParamExecData
*
* ParamExecData entries are used for executor internal parameters
* (that is, values being passed into or out of a sub-query). The
* paramid of a PARAM_EXEC Param is a (zero-based) index into an
* array of ParamExecData records, which is referenced through
* es_param_exec_vals or ecxt_param_exec_vals.
*
* If execPlan is not NULL, it points to a SubPlanState node that needs
* to be executed to produce the value. (This is done so that we can have
* lazy evaluation of InitPlans: they aren't executed until/unless a
* result value is needed.) Otherwise the value is assumed to be valid
* when needed.
* ----------------
*/
typedef struct ParamExecData
{
void *execPlan; /* should be "SubPlanState *" */
Datum value;
bool isnull;
} ParamExecData;
/* type of argument for ParamsErrorCallback */
typedef struct ParamsErrorCbData
{
const char *portalName;
ParamListInfo params;
} ParamsErrorCbData;
/* Functions found in src/backend/nodes/params.c */
extern ParamListInfo makeParamList(int numParams);
extern ParamListInfo copyParamList(ParamListInfo from);
extern Size EstimateParamListSpace(ParamListInfo paramLI);
extern void SerializeParamList(ParamListInfo paramLI, char **start_address);
extern ParamListInfo RestoreParamList(char **start_address);
extern char *BuildParamLogString(ParamListInfo params, char **paramTextValues,
int valueLen);
extern void ParamsErrorCallback(void *arg);
#endif /* PARAMS_H */
|
