pg_query 1.3.0 → 2.0.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHANGELOG.md +86 -52
- data/README.md +72 -65
- data/Rakefile +82 -1
- data/ext/pg_query/extconf.rb +2 -39
- data/ext/pg_query/guc-file.c +0 -0
- data/ext/pg_query/pg_query.c +104 -0
- data/ext/pg_query/pg_query.pb-c.c +37628 -0
- data/ext/pg_query/pg_query_deparse.c +9953 -0
- data/ext/pg_query/pg_query_fingerprint.c +292 -0
- data/ext/pg_query/pg_query_fingerprint.h +8 -0
- data/ext/pg_query/pg_query_internal.h +24 -0
- data/ext/pg_query/pg_query_json_plpgsql.c +738 -0
- data/ext/pg_query/pg_query_json_plpgsql.h +9 -0
- data/ext/pg_query/pg_query_normalize.c +437 -0
- data/ext/pg_query/pg_query_outfuncs.h +10 -0
- data/ext/pg_query/pg_query_outfuncs_json.c +297 -0
- data/ext/pg_query/pg_query_outfuncs_protobuf.c +237 -0
- data/ext/pg_query/pg_query_parse.c +148 -0
- data/ext/pg_query/pg_query_parse_plpgsql.c +460 -0
- data/ext/pg_query/pg_query_readfuncs.h +11 -0
- data/ext/pg_query/pg_query_readfuncs_protobuf.c +142 -0
- data/ext/pg_query/pg_query_ruby.c +108 -12
- data/ext/pg_query/pg_query_scan.c +173 -0
- data/ext/pg_query/pg_query_split.c +221 -0
- data/ext/pg_query/protobuf-c.c +3660 -0
- data/ext/pg_query/src_backend_catalog_namespace.c +1051 -0
- data/ext/pg_query/src_backend_catalog_pg_proc.c +142 -0
- data/ext/pg_query/src_backend_commands_define.c +117 -0
- data/ext/pg_query/src_backend_libpq_pqcomm.c +651 -0
- data/ext/pg_query/src_backend_nodes_bitmapset.c +513 -0
- data/ext/pg_query/src_backend_nodes_copyfuncs.c +6013 -0
- data/ext/pg_query/src_backend_nodes_equalfuncs.c +4003 -0
- data/ext/pg_query/src_backend_nodes_extensible.c +99 -0
- data/ext/pg_query/src_backend_nodes_list.c +922 -0
- data/ext/pg_query/src_backend_nodes_makefuncs.c +417 -0
- data/ext/pg_query/src_backend_nodes_nodeFuncs.c +1363 -0
- data/ext/pg_query/src_backend_nodes_value.c +84 -0
- data/ext/pg_query/src_backend_parser_gram.c +47456 -0
- data/ext/pg_query/src_backend_parser_parse_expr.c +313 -0
- data/ext/pg_query/src_backend_parser_parser.c +497 -0
- data/ext/pg_query/src_backend_parser_scan.c +7091 -0
- data/ext/pg_query/src_backend_parser_scansup.c +160 -0
- data/ext/pg_query/src_backend_postmaster_postmaster.c +2230 -0
- data/ext/pg_query/src_backend_storage_ipc_ipc.c +192 -0
- data/ext/pg_query/src_backend_storage_lmgr_s_lock.c +370 -0
- data/ext/pg_query/src_backend_tcop_postgres.c +776 -0
- data/ext/pg_query/src_backend_utils_adt_datum.c +326 -0
- data/ext/pg_query/src_backend_utils_adt_expandeddatum.c +98 -0
- data/ext/pg_query/src_backend_utils_adt_format_type.c +136 -0
- data/ext/pg_query/src_backend_utils_adt_ruleutils.c +1683 -0
- data/ext/pg_query/src_backend_utils_error_assert.c +74 -0
- data/ext/pg_query/src_backend_utils_error_elog.c +1748 -0
- data/ext/pg_query/src_backend_utils_fmgr_fmgr.c +570 -0
- data/ext/pg_query/src_backend_utils_hash_dynahash.c +1086 -0
- data/ext/pg_query/src_backend_utils_init_globals.c +168 -0
- data/ext/pg_query/src_backend_utils_mb_mbutils.c +839 -0
- data/ext/pg_query/src_backend_utils_misc_guc.c +1831 -0
- data/ext/pg_query/src_backend_utils_mmgr_aset.c +1560 -0
- data/ext/pg_query/src_backend_utils_mmgr_mcxt.c +1006 -0
- data/ext/pg_query/src_common_encnames.c +158 -0
- data/ext/pg_query/src_common_keywords.c +39 -0
- data/ext/pg_query/src_common_kwlist_d.h +1081 -0
- data/ext/pg_query/src_common_kwlookup.c +91 -0
- data/ext/pg_query/src_common_psprintf.c +158 -0
- data/ext/pg_query/src_common_string.c +86 -0
- data/ext/pg_query/src_common_stringinfo.c +336 -0
- data/ext/pg_query/src_common_wchar.c +1651 -0
- data/ext/pg_query/src_pl_plpgsql_src_pl_comp.c +1133 -0
- data/ext/pg_query/src_pl_plpgsql_src_pl_funcs.c +877 -0
- data/ext/pg_query/src_pl_plpgsql_src_pl_gram.c +6533 -0
- data/ext/pg_query/src_pl_plpgsql_src_pl_handler.c +107 -0
- data/ext/pg_query/src_pl_plpgsql_src_pl_reserved_kwlist_d.h +123 -0
- data/ext/pg_query/src_pl_plpgsql_src_pl_scanner.c +671 -0
- data/ext/pg_query/src_pl_plpgsql_src_pl_unreserved_kwlist_d.h +255 -0
- data/ext/pg_query/src_port_erand48.c +127 -0
- data/ext/pg_query/src_port_pg_bitutils.c +246 -0
- data/ext/pg_query/src_port_pgsleep.c +69 -0
- data/ext/pg_query/src_port_pgstrcasecmp.c +83 -0
- data/ext/pg_query/src_port_qsort.c +240 -0
- data/ext/pg_query/src_port_random.c +31 -0
- data/ext/pg_query/src_port_snprintf.c +1449 -0
- data/ext/pg_query/src_port_strerror.c +324 -0
- data/ext/pg_query/src_port_strnlen.c +39 -0
- data/ext/pg_query/xxhash.c +43 -0
- data/lib/pg_query.rb +7 -4
- data/lib/pg_query/constants.rb +21 -0
- data/lib/pg_query/deparse.rb +15 -1673
- data/lib/pg_query/filter_columns.rb +86 -85
- data/lib/pg_query/fingerprint.rb +122 -87
- data/lib/pg_query/json_field_names.rb +1402 -0
- data/lib/pg_query/node.rb +31 -0
- data/lib/pg_query/param_refs.rb +42 -37
- data/lib/pg_query/parse.rb +220 -203
- data/lib/pg_query/parse_error.rb +1 -1
- data/lib/pg_query/pg_query_pb.rb +3211 -0
- data/lib/pg_query/scan.rb +23 -0
- data/lib/pg_query/treewalker.rb +24 -40
- data/lib/pg_query/truncate.rb +64 -43
- data/lib/pg_query/version.rb +2 -2
- metadata +101 -11
- data/ext/pg_query/pg_query_ruby.h +0 -10
- data/lib/pg_query/deep_dup.rb +0 -16
- data/lib/pg_query/deparse/alter_table.rb +0 -42
- data/lib/pg_query/deparse/interval.rb +0 -105
- data/lib/pg_query/deparse/keywords.rb +0 -159
- data/lib/pg_query/deparse/rename.rb +0 -41
- data/lib/pg_query/legacy_parsetree.rb +0 -109
- data/lib/pg_query/node_types.rb +0 -297
@@ -0,0 +1,570 @@
|
|
1
|
+
/*--------------------------------------------------------------------
|
2
|
+
* Symbols referenced in this file:
|
3
|
+
* - FunctionCall5Coll
|
4
|
+
*--------------------------------------------------------------------
|
5
|
+
*/
|
6
|
+
|
7
|
+
/*-------------------------------------------------------------------------
|
8
|
+
*
|
9
|
+
* fmgr.c
|
10
|
+
* The Postgres function manager.
|
11
|
+
*
|
12
|
+
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
|
13
|
+
* Portions Copyright (c) 1994, Regents of the University of California
|
14
|
+
*
|
15
|
+
*
|
16
|
+
* IDENTIFICATION
|
17
|
+
* src/backend/utils/fmgr/fmgr.c
|
18
|
+
*
|
19
|
+
*-------------------------------------------------------------------------
|
20
|
+
*/
|
21
|
+
|
22
|
+
#include "postgres.h"
|
23
|
+
|
24
|
+
#include "access/detoast.h"
|
25
|
+
#include "catalog/pg_language.h"
|
26
|
+
#include "catalog/pg_proc.h"
|
27
|
+
#include "catalog/pg_type.h"
|
28
|
+
#include "executor/functions.h"
|
29
|
+
#include "lib/stringinfo.h"
|
30
|
+
#include "miscadmin.h"
|
31
|
+
#include "nodes/makefuncs.h"
|
32
|
+
#include "nodes/nodeFuncs.h"
|
33
|
+
#include "pgstat.h"
|
34
|
+
#include "utils/acl.h"
|
35
|
+
#include "utils/builtins.h"
|
36
|
+
#include "utils/fmgrtab.h"
|
37
|
+
#include "utils/guc.h"
|
38
|
+
#include "utils/lsyscache.h"
|
39
|
+
#include "utils/syscache.h"
|
40
|
+
|
41
|
+
/*
|
42
|
+
* Hooks for function calls
|
43
|
+
*/
|
44
|
+
PGDLLIMPORT
|
45
|
+
|
46
|
+
PGDLLIMPORT
|
47
|
+
|
48
|
+
|
49
|
+
/*
|
50
|
+
* Hashtable for fast lookup of external C functions
|
51
|
+
*/
|
52
|
+
typedef struct
|
53
|
+
{
|
54
|
+
/* fn_oid is the hash key and so must be first! */
|
55
|
+
Oid fn_oid; /* OID of an external C function */
|
56
|
+
TransactionId fn_xmin; /* for checking up-to-dateness */
|
57
|
+
ItemPointerData fn_tid;
|
58
|
+
PGFunction user_fn; /* the function's address */
|
59
|
+
const Pg_finfo_record *inforec; /* address of its info record */
|
60
|
+
} CFuncHashTabEntry;
|
61
|
+
|
62
|
+
|
63
|
+
|
64
|
+
|
65
|
+
static void fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt,
|
66
|
+
bool ignore_security);
|
67
|
+
static void fmgr_info_C_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple);
|
68
|
+
static void fmgr_info_other_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple);
|
69
|
+
static CFuncHashTabEntry *lookup_C_func(HeapTuple procedureTuple);
|
70
|
+
static void record_C_func(HeapTuple procedureTuple,
|
71
|
+
PGFunction user_fn, const Pg_finfo_record *inforec);
|
72
|
+
|
73
|
+
/* extern so it's callable via JIT */
|
74
|
+
extern Datum fmgr_security_definer(PG_FUNCTION_ARGS);
|
75
|
+
|
76
|
+
|
77
|
+
/*
|
78
|
+
* Lookup routines for builtin-function table. We can search by either Oid
|
79
|
+
* or name, but search by Oid is much faster.
|
80
|
+
*/
|
81
|
+
|
82
|
+
|
83
|
+
|
84
|
+
/*
|
85
|
+
* Lookup a builtin by name. Note there can be more than one entry in
|
86
|
+
* the array with the same name, but they should all point to the same
|
87
|
+
* routine.
|
88
|
+
*/
|
89
|
+
|
90
|
+
|
91
|
+
/*
|
92
|
+
* This routine fills a FmgrInfo struct, given the OID
|
93
|
+
* of the function to be called.
|
94
|
+
*
|
95
|
+
* The caller's CurrentMemoryContext is used as the fn_mcxt of the info
|
96
|
+
* struct; this means that any subsidiary data attached to the info struct
|
97
|
+
* (either by fmgr_info itself, or later on by a function call handler)
|
98
|
+
* will be allocated in that context. The caller must ensure that this
|
99
|
+
* context is at least as long-lived as the info struct itself. This is
|
100
|
+
* not a problem in typical cases where the info struct is on the stack or
|
101
|
+
* in freshly-palloc'd space. However, if one intends to store an info
|
102
|
+
* struct in a long-lived table, it's better to use fmgr_info_cxt.
|
103
|
+
*/
|
104
|
+
|
105
|
+
|
106
|
+
/*
|
107
|
+
* Fill a FmgrInfo struct, specifying a memory context in which its
|
108
|
+
* subsidiary data should go.
|
109
|
+
*/
|
110
|
+
|
111
|
+
|
112
|
+
/*
|
113
|
+
* This one does the actual work. ignore_security is ordinarily false
|
114
|
+
* but is set to true when we need to avoid recursion.
|
115
|
+
*/
|
116
|
+
|
117
|
+
|
118
|
+
/*
|
119
|
+
* Return module and C function name providing implementation of functionId.
|
120
|
+
*
|
121
|
+
* If *mod == NULL and *fn == NULL, no C symbol is known to implement
|
122
|
+
* function.
|
123
|
+
*
|
124
|
+
* If *mod == NULL and *fn != NULL, the function is implemented by a symbol in
|
125
|
+
* the main binary.
|
126
|
+
*
|
127
|
+
* If *mod != NULL and *fn !=NULL the function is implemented in an extension
|
128
|
+
* shared object.
|
129
|
+
*
|
130
|
+
* The returned module and function names are pstrdup'ed into the current
|
131
|
+
* memory context.
|
132
|
+
*/
|
133
|
+
|
134
|
+
|
135
|
+
|
136
|
+
/*
|
137
|
+
* Special fmgr_info processing for C-language functions. Note that
|
138
|
+
* finfo->fn_oid is not valid yet.
|
139
|
+
*/
|
140
|
+
|
141
|
+
|
142
|
+
/*
|
143
|
+
* Special fmgr_info processing for other-language functions. Note
|
144
|
+
* that finfo->fn_oid is not valid yet.
|
145
|
+
*/
|
146
|
+
|
147
|
+
|
148
|
+
/*
|
149
|
+
* Fetch and validate the information record for the given external function.
|
150
|
+
* The function is specified by a handle for the containing library
|
151
|
+
* (obtained from load_external_function) as well as the function name.
|
152
|
+
*
|
153
|
+
* If no info function exists for the given name an error is raised.
|
154
|
+
*
|
155
|
+
* This function is broken out of fmgr_info_C_lang so that fmgr_c_validator
|
156
|
+
* can validate the information record for a function not yet entered into
|
157
|
+
* pg_proc.
|
158
|
+
*/
|
159
|
+
|
160
|
+
|
161
|
+
|
162
|
+
/*-------------------------------------------------------------------------
|
163
|
+
* Routines for caching lookup information for external C functions.
|
164
|
+
*
|
165
|
+
* The routines in dfmgr.c are relatively slow, so we try to avoid running
|
166
|
+
* them more than once per external function per session. We use a hash table
|
167
|
+
* with the function OID as the lookup key.
|
168
|
+
*-------------------------------------------------------------------------
|
169
|
+
*/
|
170
|
+
|
171
|
+
/*
|
172
|
+
* lookup_C_func: try to find a C function in the hash table
|
173
|
+
*
|
174
|
+
* If an entry exists and is up to date, return it; else return NULL
|
175
|
+
*/
|
176
|
+
|
177
|
+
|
178
|
+
/*
|
179
|
+
* record_C_func: enter (or update) info about a C function in the hash table
|
180
|
+
*/
|
181
|
+
|
182
|
+
|
183
|
+
/*
|
184
|
+
* clear_external_function_hash: remove entries for a library being closed
|
185
|
+
*
|
186
|
+
* Presently we just zap the entire hash table, but later it might be worth
|
187
|
+
* the effort to remove only the entries associated with the given handle.
|
188
|
+
*/
|
189
|
+
|
190
|
+
|
191
|
+
|
192
|
+
/*
|
193
|
+
* Copy an FmgrInfo struct
|
194
|
+
*
|
195
|
+
* This is inherently somewhat bogus since we can't reliably duplicate
|
196
|
+
* language-dependent subsidiary info. We cheat by zeroing fn_extra,
|
197
|
+
* instead, meaning that subsidiary info will have to be recomputed.
|
198
|
+
*/
|
199
|
+
|
200
|
+
|
201
|
+
|
202
|
+
/*
|
203
|
+
* Specialized lookup routine for fmgr_internal_validator: given the alleged
|
204
|
+
* name of an internal function, return the OID of the function.
|
205
|
+
* If the name is not recognized, return InvalidOid.
|
206
|
+
*/
|
207
|
+
|
208
|
+
|
209
|
+
|
210
|
+
/*
|
211
|
+
* Support for security-definer and proconfig-using functions. We support
|
212
|
+
* both of these features using the same call handler, because they are
|
213
|
+
* often used together and it would be inefficient (as well as notationally
|
214
|
+
* messy) to have two levels of call handler involved.
|
215
|
+
*/
|
216
|
+
struct fmgr_security_definer_cache
|
217
|
+
{
|
218
|
+
FmgrInfo flinfo; /* lookup info for target function */
|
219
|
+
Oid userid; /* userid to set, or InvalidOid */
|
220
|
+
ArrayType *proconfig; /* GUC values to set, or NULL */
|
221
|
+
Datum arg; /* passthrough argument for plugin modules */
|
222
|
+
};
|
223
|
+
|
224
|
+
/*
|
225
|
+
* Function handler for security-definer/proconfig/plugin-hooked functions.
|
226
|
+
* We extract the OID of the actual function and do a fmgr lookup again.
|
227
|
+
* Then we fetch the pg_proc row and copy the owner ID and proconfig fields.
|
228
|
+
* (All this info is cached for the duration of the current query.)
|
229
|
+
* To execute a call, we temporarily replace the flinfo with the cached
|
230
|
+
* and looked-up one, while keeping the outer fcinfo (which contains all
|
231
|
+
* the actual arguments, etc.) intact. This is not re-entrant, but then
|
232
|
+
* the fcinfo itself can't be used reentrantly anyway.
|
233
|
+
*/
|
234
|
+
|
235
|
+
|
236
|
+
|
237
|
+
/*-------------------------------------------------------------------------
|
238
|
+
* Support routines for callers of fmgr-compatible functions
|
239
|
+
*-------------------------------------------------------------------------
|
240
|
+
*/
|
241
|
+
|
242
|
+
/*
|
243
|
+
* These are for invocation of a specifically named function with a
|
244
|
+
* directly-computed parameter list. Note that neither arguments nor result
|
245
|
+
* are allowed to be NULL. Also, the function cannot be one that needs to
|
246
|
+
* look at FmgrInfo, since there won't be any.
|
247
|
+
*/
|
248
|
+
|
249
|
+
|
250
|
+
|
251
|
+
|
252
|
+
|
253
|
+
|
254
|
+
|
255
|
+
|
256
|
+
|
257
|
+
|
258
|
+
|
259
|
+
|
260
|
+
|
261
|
+
|
262
|
+
|
263
|
+
|
264
|
+
|
265
|
+
|
266
|
+
/*
|
267
|
+
* These functions work like the DirectFunctionCall functions except that
|
268
|
+
* they use the flinfo parameter to initialise the fcinfo for the call.
|
269
|
+
* It's recommended that the callee only use the fn_extra and fn_mcxt
|
270
|
+
* fields, as other fields will typically describe the calling function
|
271
|
+
* not the callee. Conversely, the calling function should not have
|
272
|
+
* used fn_extra, unless its use is known to be compatible with the callee's.
|
273
|
+
*/
|
274
|
+
|
275
|
+
|
276
|
+
|
277
|
+
|
278
|
+
|
279
|
+
/*
|
280
|
+
* These are for invocation of a previously-looked-up function with a
|
281
|
+
* directly-computed parameter list. Note that neither arguments nor result
|
282
|
+
* are allowed to be NULL.
|
283
|
+
*/
|
284
|
+
|
285
|
+
|
286
|
+
|
287
|
+
|
288
|
+
|
289
|
+
|
290
|
+
|
291
|
+
|
292
|
+
|
293
|
+
|
294
|
+
Datum
|
295
|
+
FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
|
296
|
+
Datum arg3, Datum arg4, Datum arg5)
|
297
|
+
{
|
298
|
+
LOCAL_FCINFO(fcinfo, 5);
|
299
|
+
Datum result;
|
300
|
+
|
301
|
+
InitFunctionCallInfoData(*fcinfo, flinfo, 5, collation, NULL, NULL);
|
302
|
+
|
303
|
+
fcinfo->args[0].value = arg1;
|
304
|
+
fcinfo->args[0].isnull = false;
|
305
|
+
fcinfo->args[1].value = arg2;
|
306
|
+
fcinfo->args[1].isnull = false;
|
307
|
+
fcinfo->args[2].value = arg3;
|
308
|
+
fcinfo->args[2].isnull = false;
|
309
|
+
fcinfo->args[3].value = arg4;
|
310
|
+
fcinfo->args[3].isnull = false;
|
311
|
+
fcinfo->args[4].value = arg5;
|
312
|
+
fcinfo->args[4].isnull = false;
|
313
|
+
|
314
|
+
result = FunctionCallInvoke(fcinfo);
|
315
|
+
|
316
|
+
/* Check for null result, since caller is clearly not expecting one */
|
317
|
+
if (fcinfo->isnull)
|
318
|
+
elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
|
319
|
+
|
320
|
+
return result;
|
321
|
+
}
|
322
|
+
|
323
|
+
|
324
|
+
|
325
|
+
|
326
|
+
|
327
|
+
|
328
|
+
|
329
|
+
|
330
|
+
|
331
|
+
|
332
|
+
/*
|
333
|
+
* These are for invocation of a function identified by OID with a
|
334
|
+
* directly-computed parameter list. Note that neither arguments nor result
|
335
|
+
* are allowed to be NULL. These are essentially fmgr_info() followed
|
336
|
+
* by FunctionCallN(). If the same function is to be invoked repeatedly,
|
337
|
+
* do the fmgr_info() once and then use FunctionCallN().
|
338
|
+
*/
|
339
|
+
|
340
|
+
|
341
|
+
|
342
|
+
|
343
|
+
|
344
|
+
|
345
|
+
|
346
|
+
|
347
|
+
|
348
|
+
|
349
|
+
|
350
|
+
|
351
|
+
|
352
|
+
|
353
|
+
|
354
|
+
|
355
|
+
|
356
|
+
|
357
|
+
|
358
|
+
|
359
|
+
|
360
|
+
/*
|
361
|
+
* Special cases for convenient invocation of datatype I/O functions.
|
362
|
+
*/
|
363
|
+
|
364
|
+
/*
|
365
|
+
* Call a previously-looked-up datatype input function.
|
366
|
+
*
|
367
|
+
* "str" may be NULL to indicate we are reading a NULL. In this case
|
368
|
+
* the caller should assume the result is NULL, but we'll call the input
|
369
|
+
* function anyway if it's not strict. So this is almost but not quite
|
370
|
+
* the same as FunctionCall3.
|
371
|
+
*/
|
372
|
+
|
373
|
+
|
374
|
+
/*
|
375
|
+
* Call a previously-looked-up datatype output function.
|
376
|
+
*
|
377
|
+
* Do not call this on NULL datums.
|
378
|
+
*
|
379
|
+
* This is currently little more than window dressing for FunctionCall1.
|
380
|
+
*/
|
381
|
+
|
382
|
+
|
383
|
+
/*
|
384
|
+
* Call a previously-looked-up datatype binary-input function.
|
385
|
+
*
|
386
|
+
* "buf" may be NULL to indicate we are reading a NULL. In this case
|
387
|
+
* the caller should assume the result is NULL, but we'll call the receive
|
388
|
+
* function anyway if it's not strict. So this is almost but not quite
|
389
|
+
* the same as FunctionCall3.
|
390
|
+
*/
|
391
|
+
|
392
|
+
|
393
|
+
/*
|
394
|
+
* Call a previously-looked-up datatype binary-output function.
|
395
|
+
*
|
396
|
+
* Do not call this on NULL datums.
|
397
|
+
*
|
398
|
+
* This is little more than window dressing for FunctionCall1, but it does
|
399
|
+
* guarantee a non-toasted result, which strictly speaking the underlying
|
400
|
+
* function doesn't.
|
401
|
+
*/
|
402
|
+
|
403
|
+
|
404
|
+
/*
|
405
|
+
* As above, for I/O functions identified by OID. These are only to be used
|
406
|
+
* in seldom-executed code paths. They are not only slow but leak memory.
|
407
|
+
*/
|
408
|
+
|
409
|
+
|
410
|
+
|
411
|
+
|
412
|
+
|
413
|
+
|
414
|
+
|
415
|
+
|
416
|
+
|
417
|
+
/*-------------------------------------------------------------------------
|
418
|
+
* Support routines for standard maybe-pass-by-reference datatypes
|
419
|
+
*
|
420
|
+
* int8 and float8 can be passed by value if Datum is wide enough.
|
421
|
+
* (For backwards-compatibility reasons, we allow pass-by-ref to be chosen
|
422
|
+
* at compile time even if pass-by-val is possible.)
|
423
|
+
*
|
424
|
+
* Note: there is only one switch controlling the pass-by-value option for
|
425
|
+
* both int8 and float8; this is to avoid making things unduly complicated
|
426
|
+
* for the timestamp types, which might have either representation.
|
427
|
+
*-------------------------------------------------------------------------
|
428
|
+
*/
|
429
|
+
|
430
|
+
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
|
431
|
+
|
432
|
+
Datum
|
433
|
+
Int64GetDatum(int64 X)
|
434
|
+
{
|
435
|
+
int64 *retval = (int64 *) palloc(sizeof(int64));
|
436
|
+
|
437
|
+
*retval = X;
|
438
|
+
return PointerGetDatum(retval);
|
439
|
+
}
|
440
|
+
|
441
|
+
Datum
|
442
|
+
Float8GetDatum(float8 X)
|
443
|
+
{
|
444
|
+
float8 *retval = (float8 *) palloc(sizeof(float8));
|
445
|
+
|
446
|
+
*retval = X;
|
447
|
+
return PointerGetDatum(retval);
|
448
|
+
}
|
449
|
+
#endif /* USE_FLOAT8_BYVAL */
|
450
|
+
|
451
|
+
|
452
|
+
/*-------------------------------------------------------------------------
|
453
|
+
* Support routines for toastable datatypes
|
454
|
+
*-------------------------------------------------------------------------
|
455
|
+
*/
|
456
|
+
|
457
|
+
|
458
|
+
|
459
|
+
|
460
|
+
|
461
|
+
|
462
|
+
|
463
|
+
|
464
|
+
|
465
|
+
/*-------------------------------------------------------------------------
|
466
|
+
* Support routines for extracting info from fn_expr parse tree
|
467
|
+
*
|
468
|
+
* These are needed by polymorphic functions, which accept multiple possible
|
469
|
+
* input types and need help from the parser to know what they've got.
|
470
|
+
* Also, some functions might be interested in whether a parameter is constant.
|
471
|
+
* Functions taking VARIADIC ANY also need to know about the VARIADIC keyword.
|
472
|
+
*-------------------------------------------------------------------------
|
473
|
+
*/
|
474
|
+
|
475
|
+
/*
|
476
|
+
* Get the actual type OID of the function return type
|
477
|
+
*
|
478
|
+
* Returns InvalidOid if information is not available
|
479
|
+
*/
|
480
|
+
|
481
|
+
|
482
|
+
/*
|
483
|
+
* Get the actual type OID of a specific function argument (counting from 0)
|
484
|
+
*
|
485
|
+
* Returns InvalidOid if information is not available
|
486
|
+
*/
|
487
|
+
|
488
|
+
|
489
|
+
/*
|
490
|
+
* Get the actual type OID of a specific function argument (counting from 0),
|
491
|
+
* but working from the calling expression tree instead of FmgrInfo
|
492
|
+
*
|
493
|
+
* Returns InvalidOid if information is not available
|
494
|
+
*/
|
495
|
+
|
496
|
+
|
497
|
+
/*
|
498
|
+
* Find out whether a specific function argument is constant for the
|
499
|
+
* duration of a query
|
500
|
+
*
|
501
|
+
* Returns false if information is not available
|
502
|
+
*/
|
503
|
+
|
504
|
+
|
505
|
+
/*
|
506
|
+
* Find out whether a specific function argument is constant for the
|
507
|
+
* duration of a query, but working from the calling expression tree
|
508
|
+
*
|
509
|
+
* Returns false if information is not available
|
510
|
+
*/
|
511
|
+
|
512
|
+
|
513
|
+
/*
|
514
|
+
* Get the VARIADIC flag from the function invocation
|
515
|
+
*
|
516
|
+
* Returns false (the default assumption) if information is not available
|
517
|
+
*
|
518
|
+
* Note this is generally only of interest to VARIADIC ANY functions
|
519
|
+
*/
|
520
|
+
|
521
|
+
|
522
|
+
/*
|
523
|
+
* Set options to FmgrInfo of opclass support function.
|
524
|
+
*
|
525
|
+
* Opclass support functions are called outside of expressions. Thanks to that
|
526
|
+
* we can use fn_expr to store opclass options as bytea constant.
|
527
|
+
*/
|
528
|
+
|
529
|
+
|
530
|
+
/*
|
531
|
+
* Check if options are defined for opclass support function.
|
532
|
+
*/
|
533
|
+
|
534
|
+
|
535
|
+
/*
|
536
|
+
* Get options for opclass support function.
|
537
|
+
*/
|
538
|
+
|
539
|
+
|
540
|
+
/*-------------------------------------------------------------------------
|
541
|
+
* Support routines for procedural language implementations
|
542
|
+
*-------------------------------------------------------------------------
|
543
|
+
*/
|
544
|
+
|
545
|
+
/*
|
546
|
+
* Verify that a validator is actually associated with the language of a
|
547
|
+
* particular function and that the user has access to both the language and
|
548
|
+
* the function. All validators should call this before doing anything
|
549
|
+
* substantial. Doing so ensures a user cannot achieve anything with explicit
|
550
|
+
* calls to validators that he could not achieve with CREATE FUNCTION or by
|
551
|
+
* simply calling an existing function.
|
552
|
+
*
|
553
|
+
* When this function returns false, callers should skip all validation work
|
554
|
+
* and call PG_RETURN_VOID(). This never happens at present; it is reserved
|
555
|
+
* for future expansion.
|
556
|
+
*
|
557
|
+
* In particular, checking that the validator corresponds to the function's
|
558
|
+
* language allows untrusted language validators to assume they process only
|
559
|
+
* superuser-chosen source code. (Untrusted language call handlers, by
|
560
|
+
* definition, do assume that.) A user lacking the USAGE language privilege
|
561
|
+
* would be unable to reach the validator through CREATE FUNCTION, so we check
|
562
|
+
* that to block explicit calls as well. Checking the EXECUTE privilege on
|
563
|
+
* the function is often superfluous, because most users can clone the
|
564
|
+
* function to get an executable copy. It is meaningful against users with no
|
565
|
+
* database TEMP right and no permanent schema CREATE right, thereby unable to
|
566
|
+
* create any function. Also, if the function tracks persistent state by
|
567
|
+
* function OID or name, validating the original function might permit more
|
568
|
+
* mischief than creating and validating a clone thereof.
|
569
|
+
*/
|
570
|
+
|