Age Owner Branch data TLA Line data Source code
1 : : /**********************************************************************
2 : : * pltcl.c - PostgreSQL support for Tcl as
3 : : * procedural language (PL)
4 : : *
5 : : * src/pl/tcl/pltcl.c
6 : : *
7 : : **********************************************************************/
8 : :
9 : : #include "postgres.h"
10 : :
11 : : #include <tcl.h>
12 : :
13 : : #include <unistd.h>
14 : : #include <fcntl.h>
15 : :
16 : : #include "access/htup_details.h"
17 : : #include "access/xact.h"
18 : : #include "catalog/objectaccess.h"
19 : : #include "catalog/pg_proc.h"
20 : : #include "catalog/pg_type.h"
21 : : #include "commands/event_trigger.h"
22 : : #include "commands/trigger.h"
23 : : #include "executor/spi.h"
24 : : #include "fmgr.h"
25 : : #include "funcapi.h"
26 : : #include "mb/pg_wchar.h"
27 : : #include "miscadmin.h"
28 : : #include "nodes/makefuncs.h"
29 : : #include "parser/parse_func.h"
30 : : #include "parser/parse_type.h"
31 : : #include "pgstat.h"
32 : : #include "tcop/tcopprot.h"
33 : : #include "utils/acl.h"
34 : : #include "utils/builtins.h"
35 : : #include "utils/lsyscache.h"
36 : : #include "utils/memutils.h"
37 : : #include "utils/regproc.h"
38 : : #include "utils/rel.h"
39 : : #include "utils/syscache.h"
40 : : #include "utils/typcache.h"
41 : :
42 : :
2965 tgl@sss.pgh.pa.us 43 :CBC 9 : PG_MODULE_MAGIC;
44 : :
45 : : #define HAVE_TCL_VERSION(maj,min) \
46 : : ((TCL_MAJOR_VERSION > maj) || \
47 : : (TCL_MAJOR_VERSION == maj && TCL_MINOR_VERSION >= min))
48 : :
49 : : /* Insist on Tcl >= 8.4 */
50 : : #if !HAVE_TCL_VERSION(8,4)
51 : : #error PostgreSQL only supports Tcl 8.4 or later.
52 : : #endif
53 : :
54 : : /* Hack to deal with Tcl 8.6 const-ification without losing compatibility */
55 : : #ifndef CONST86
56 : : #define CONST86
57 : : #endif
58 : :
59 : : /* define our text domain for translations */
60 : : #undef TEXTDOMAIN
61 : : #define TEXTDOMAIN PG_TEXTDOMAIN("pltcl")
62 : :
63 : :
64 : : /*
65 : : * Support for converting between UTF8 (which is what all strings going into
66 : : * or out of Tcl should be) and the database encoding.
67 : : *
68 : : * If you just use utf_u2e() or utf_e2u() directly, they will leak some
69 : : * palloc'd space when doing a conversion. This is not worth worrying about
70 : : * if it only happens, say, once per PL/Tcl function call. If it does seem
71 : : * worth worrying about, use the wrapper macros.
72 : : */
73 : :
74 : : static inline char *
75 : 753 : utf_u2e(const char *src)
76 : : {
77 : 753 : return pg_any_to_server(src, strlen(src), PG_UTF8);
78 : : }
79 : :
80 : : static inline char *
81 : 1337 : utf_e2u(const char *src)
82 : : {
83 : 1337 : return pg_server_to_any(src, strlen(src), PG_UTF8);
84 : : }
85 : :
86 : : #define UTF_BEGIN \
87 : : do { \
88 : : const char *_pltcl_utf_src = NULL; \
89 : : char *_pltcl_utf_dst = NULL
90 : :
91 : : #define UTF_END \
92 : : if (_pltcl_utf_src != (const char *) _pltcl_utf_dst) \
93 : : pfree(_pltcl_utf_dst); \
94 : : } while (0)
95 : :
96 : : #define UTF_U2E(x) \
97 : : (_pltcl_utf_dst = utf_u2e(_pltcl_utf_src = (x)))
98 : :
99 : : #define UTF_E2U(x) \
100 : : (_pltcl_utf_dst = utf_e2u(_pltcl_utf_src = (x)))
101 : :
102 : :
103 : : /**********************************************************************
104 : : * Information associated with a Tcl interpreter. We have one interpreter
105 : : * that is used for all pltclu (untrusted) functions. For pltcl (trusted)
106 : : * functions, there is a separate interpreter for each effective SQL userid.
107 : : * (This is needed to ensure that an unprivileged user can't inject Tcl code
108 : : * that'll be executed with the privileges of some other SQL user.)
109 : : *
110 : : * The pltcl_interp_desc structs are kept in a Postgres hash table indexed
111 : : * by userid OID, with OID 0 used for the single untrusted interpreter.
112 : : **********************************************************************/
113 : : typedef struct pltcl_interp_desc
114 : : {
115 : : Oid user_id; /* Hash key (must be first!) */
116 : : Tcl_Interp *interp; /* The interpreter */
117 : : Tcl_HashTable query_hash; /* pltcl_query_desc structs */
118 : : } pltcl_interp_desc;
119 : :
120 : :
121 : : /**********************************************************************
122 : : * The information we cache about loaded procedures
123 : : *
124 : : * The pltcl_proc_desc struct itself, as well as all subsidiary data,
125 : : * is stored in the memory context identified by the fn_cxt field.
126 : : * We can reclaim all the data by deleting that context, and should do so
127 : : * when the fn_refcount goes to zero. (But note that we do not bother
128 : : * trying to clean up Tcl's copy of the procedure definition: it's Tcl's
129 : : * problem to manage its memory when we replace a proc definition. We do
130 : : * not clean up pltcl_proc_descs when a pg_proc row is deleted, only when
131 : : * it is updated, and the same policy applies to Tcl's copy as well.)
132 : : *
133 : : * Note that the data in this struct is shared across all active calls;
134 : : * nothing except the fn_refcount should be changed by a call instance.
135 : : **********************************************************************/
136 : : typedef struct pltcl_proc_desc
137 : : {
138 : : char *user_proname; /* user's name (from pg_proc.proname) */
139 : : char *internal_proname; /* Tcl name (based on function OID) */
140 : : MemoryContext fn_cxt; /* memory context for this procedure */
141 : : unsigned long fn_refcount; /* number of active references */
142 : : TransactionId fn_xmin; /* xmin of pg_proc row */
143 : : ItemPointerData fn_tid; /* TID of pg_proc row */
144 : : bool fn_readonly; /* is function readonly? */
145 : : bool lanpltrusted; /* is it pltcl (vs. pltclu)? */
146 : : pltcl_interp_desc *interp_desc; /* interpreter to use */
147 : : Oid result_typid; /* OID of fn's result type */
148 : : FmgrInfo result_in_func; /* input function for fn's result type */
149 : : Oid result_typioparam; /* param to pass to same */
150 : : bool fn_retisset; /* true if function returns a set */
151 : : bool fn_retistuple; /* true if function returns composite */
152 : : bool fn_retisdomain; /* true if function returns domain */
153 : : void *domain_info; /* opaque cache for domain checks */
154 : : int nargs; /* number of arguments */
155 : : /* these arrays have nargs entries: */
156 : : FmgrInfo *arg_out_func; /* output fns for arg types */
157 : : bool *arg_is_rowtype; /* is each arg composite? */
158 : : } pltcl_proc_desc;
159 : :
160 : :
161 : : /**********************************************************************
162 : : * The information we cache about prepared and saved plans
163 : : **********************************************************************/
164 : : typedef struct pltcl_query_desc
165 : : {
166 : : char qname[20];
167 : : SPIPlanPtr plan;
168 : : int nargs;
169 : : Oid *argtypes;
170 : : FmgrInfo *arginfuncs;
171 : : Oid *argtypioparams;
172 : : } pltcl_query_desc;
173 : :
174 : :
175 : : /**********************************************************************
176 : : * For speedy lookup, we maintain a hash table mapping from
177 : : * function OID + trigger flag + user OID to pltcl_proc_desc pointers.
178 : : * The reason the pltcl_proc_desc struct isn't directly part of the hash
179 : : * entry is to simplify recovery from errors during compile_pltcl_function.
180 : : *
181 : : * Note: if the same function is called by multiple userIDs within a session,
182 : : * there will be a separate pltcl_proc_desc entry for each userID in the case
183 : : * of pltcl functions, but only one entry for pltclu functions, because we
184 : : * set user_id = 0 for that case.
185 : : **********************************************************************/
186 : : typedef struct pltcl_proc_key
187 : : {
188 : : Oid proc_id; /* Function OID */
189 : :
190 : : /*
191 : : * is_trigger is really a bool, but declare as Oid to ensure this struct
192 : : * contains no padding
193 : : */
194 : : Oid is_trigger; /* is it a trigger function? */
195 : : Oid user_id; /* User calling the function, or 0 */
196 : : } pltcl_proc_key;
197 : :
198 : : typedef struct pltcl_proc_ptr
199 : : {
200 : : pltcl_proc_key proc_key; /* Hash key (must be first!) */
201 : : pltcl_proc_desc *proc_ptr;
202 : : } pltcl_proc_ptr;
203 : :
204 : :
205 : : /**********************************************************************
206 : : * Per-call state
207 : : **********************************************************************/
208 : : typedef struct pltcl_call_state
209 : : {
210 : : /* Call info struct, or NULL in a trigger */
211 : : FunctionCallInfo fcinfo;
212 : :
213 : : /* Trigger data, if we're in a normal (not event) trigger; else NULL */
214 : : TriggerData *trigdata;
215 : :
216 : : /* Function we're executing (NULL if not yet identified) */
217 : : pltcl_proc_desc *prodesc;
218 : :
219 : : /*
220 : : * Information for SRFs and functions returning composite types.
221 : : * ret_tupdesc and attinmeta are set up if either fn_retistuple or
222 : : * fn_retisset, since even a scalar-returning SRF needs a tuplestore.
223 : : */
224 : : TupleDesc ret_tupdesc; /* return rowtype, if retistuple or retisset */
225 : : AttInMetadata *attinmeta; /* metadata for building tuples of that type */
226 : :
227 : : ReturnSetInfo *rsi; /* passed-in ReturnSetInfo, if any */
228 : : Tuplestorestate *tuple_store; /* SRFs accumulate result here */
229 : : MemoryContext tuple_store_cxt; /* context and resowner for tuplestore */
230 : : ResourceOwner tuple_store_owner;
231 : : } pltcl_call_state;
232 : :
233 : :
234 : : /**********************************************************************
235 : : * Global data
236 : : **********************************************************************/
237 : : static char *pltcl_start_proc = NULL;
238 : : static char *pltclu_start_proc = NULL;
239 : : static bool pltcl_pm_init_done = false;
240 : : static Tcl_Interp *pltcl_hold_interp = NULL;
241 : : static HTAB *pltcl_interp_htab = NULL;
242 : : static HTAB *pltcl_proc_htab = NULL;
243 : :
244 : : /* this is saved and restored by pltcl_handler */
245 : : static pltcl_call_state *pltcl_current_call_state = NULL;
246 : :
247 : : /**********************************************************************
248 : : * Lookup table for SQLSTATE condition names
249 : : **********************************************************************/
250 : : typedef struct
251 : : {
252 : : const char *label;
253 : : int sqlerrstate;
254 : : } TclExceptionNameMap;
255 : :
256 : : static const TclExceptionNameMap exception_name_map[] = {
257 : : #include "pltclerrcodes.h" /* pgrminclude ignore */
258 : : {NULL, 0}
259 : : };
260 : :
261 : : /**********************************************************************
262 : : * Forward declarations
263 : : **********************************************************************/
264 : :
265 : : static void pltcl_init_interp(pltcl_interp_desc *interp_desc,
266 : : Oid prolang, bool pltrusted);
267 : : static pltcl_interp_desc *pltcl_fetch_interp(Oid prolang, bool pltrusted);
268 : : static void call_pltcl_start_proc(Oid prolang, bool pltrusted);
269 : : static void start_proc_error_callback(void *arg);
270 : :
271 : : static Datum pltcl_handler(PG_FUNCTION_ARGS, bool pltrusted);
272 : :
273 : : static Datum pltcl_func_handler(PG_FUNCTION_ARGS, pltcl_call_state *call_state,
274 : : bool pltrusted);
275 : : static HeapTuple pltcl_trigger_handler(PG_FUNCTION_ARGS, pltcl_call_state *call_state,
276 : : bool pltrusted);
277 : : static void pltcl_event_trigger_handler(PG_FUNCTION_ARGS, pltcl_call_state *call_state,
278 : : bool pltrusted);
279 : :
280 : : static void throw_tcl_error(Tcl_Interp *interp, const char *proname);
281 : :
282 : : static pltcl_proc_desc *compile_pltcl_function(Oid fn_oid, Oid tgreloid,
283 : : bool is_event_trigger,
284 : : bool pltrusted);
285 : :
286 : : static int pltcl_elog(ClientData cdata, Tcl_Interp *interp,
287 : : int objc, Tcl_Obj *const objv[]);
288 : : static void pltcl_construct_errorCode(Tcl_Interp *interp, ErrorData *edata);
289 : : static const char *pltcl_get_condition_name(int sqlstate);
290 : : static int pltcl_quote(ClientData cdata, Tcl_Interp *interp,
291 : : int objc, Tcl_Obj *const objv[]);
292 : : static int pltcl_argisnull(ClientData cdata, Tcl_Interp *interp,
293 : : int objc, Tcl_Obj *const objv[]);
294 : : static int pltcl_returnnull(ClientData cdata, Tcl_Interp *interp,
295 : : int objc, Tcl_Obj *const objv[]);
296 : : static int pltcl_returnnext(ClientData cdata, Tcl_Interp *interp,
297 : : int objc, Tcl_Obj *const objv[]);
298 : : static int pltcl_SPI_execute(ClientData cdata, Tcl_Interp *interp,
299 : : int objc, Tcl_Obj *const objv[]);
300 : : static int pltcl_process_SPI_result(Tcl_Interp *interp,
301 : : const char *arrayname,
302 : : Tcl_Obj *loop_body,
303 : : int spi_rc,
304 : : SPITupleTable *tuptable,
305 : : uint64 ntuples);
306 : : static int pltcl_SPI_prepare(ClientData cdata, Tcl_Interp *interp,
307 : : int objc, Tcl_Obj *const objv[]);
308 : : static int pltcl_SPI_execute_plan(ClientData cdata, Tcl_Interp *interp,
309 : : int objc, Tcl_Obj *const objv[]);
310 : : static int pltcl_subtransaction(ClientData cdata, Tcl_Interp *interp,
311 : : int objc, Tcl_Obj *const objv[]);
312 : : static int pltcl_commit(ClientData cdata, Tcl_Interp *interp,
313 : : int objc, Tcl_Obj *const objv[]);
314 : : static int pltcl_rollback(ClientData cdata, Tcl_Interp *interp,
315 : : int objc, Tcl_Obj *const objv[]);
316 : :
317 : : static void pltcl_subtrans_begin(MemoryContext oldcontext,
318 : : ResourceOwner oldowner);
319 : : static void pltcl_subtrans_commit(MemoryContext oldcontext,
320 : : ResourceOwner oldowner);
321 : : static void pltcl_subtrans_abort(Tcl_Interp *interp,
322 : : MemoryContext oldcontext,
323 : : ResourceOwner oldowner);
324 : :
325 : : static void pltcl_set_tuple_values(Tcl_Interp *interp, const char *arrayname,
326 : : uint64 tupno, HeapTuple tuple, TupleDesc tupdesc);
327 : : static Tcl_Obj *pltcl_build_tuple_argument(HeapTuple tuple, TupleDesc tupdesc, bool include_generated);
328 : : static HeapTuple pltcl_build_tuple_result(Tcl_Interp *interp,
329 : : Tcl_Obj **kvObjv, int kvObjc,
330 : : pltcl_call_state *call_state);
331 : : static void pltcl_init_tuple_store(pltcl_call_state *call_state);
332 : :
333 : :
334 : : /*
335 : : * Hack to override Tcl's builtin Notifier subsystem. This prevents the
336 : : * backend from becoming multithreaded, which breaks all sorts of things.
337 : : * That happens in the default version of Tcl_InitNotifier if the Tcl library
338 : : * has been compiled with multithreading support (i.e. when TCL_THREADS is
339 : : * defined under Unix, and in all cases under Windows).
340 : : * It's okay to disable the notifier because we never enter the Tcl event loop
341 : : * from Postgres, so the notifier capabilities are initialized, but never
342 : : * used. Only InitNotifier and DeleteFileHandler ever seem to get called
343 : : * within Postgres, but we implement all the functions for completeness.
344 : : */
345 : : static ClientData
6050 346 : 9 : pltcl_InitNotifier(void)
347 : : {
348 : : static int fakeThreadKey; /* To give valid address for ClientData */
349 : :
350 : 9 : return (ClientData) &(fakeThreadKey);
351 : : }
352 : :
353 : : static void
6050 tgl@sss.pgh.pa.us 354 :UBC 0 : pltcl_FinalizeNotifier(ClientData clientData)
355 : : {
356 : 0 : }
357 : :
358 : : static void
4091 peter_e@gmx.net 359 :CBC 1 : pltcl_SetTimer(CONST86 Tcl_Time *timePtr)
360 : : {
6050 tgl@sss.pgh.pa.us 361 : 1 : }
362 : :
363 : : static void
6050 tgl@sss.pgh.pa.us 364 :UBC 0 : pltcl_AlertNotifier(ClientData clientData)
365 : : {
366 : 0 : }
367 : :
368 : : static void
369 : 0 : pltcl_CreateFileHandler(int fd, int mask,
370 : : Tcl_FileProc *proc, ClientData clientData)
371 : : {
372 : 0 : }
373 : :
374 : : static void
6050 tgl@sss.pgh.pa.us 375 :CBC 44 : pltcl_DeleteFileHandler(int fd)
376 : : {
377 : 44 : }
378 : :
379 : : static void
6050 tgl@sss.pgh.pa.us 380 :UBC 0 : pltcl_ServiceModeHook(int mode)
381 : : {
382 : 0 : }
383 : :
384 : : static int
4091 peter_e@gmx.net 385 :CBC 429758 : pltcl_WaitForEvent(CONST86 Tcl_Time *timePtr)
386 : : {
6050 tgl@sss.pgh.pa.us 387 : 429758 : return 0;
388 : : }
389 : :
390 : :
391 : : /*
392 : : * _PG_init() - library load-time initialization
393 : : *
394 : : * DO NOT make this static nor change its name!
395 : : *
396 : : * The work done here must be safe to do in the postmaster process,
397 : : * in case the pltcl library is preloaded in the postmaster.
398 : : */
399 : : void
6459 400 : 9 : _PG_init(void)
401 : : {
402 : : Tcl_NotifierProcs notifier;
403 : : HASHCTL hash_ctl;
404 : :
405 : : /* Be sure we do initialization only once (should be redundant now) */
7563 406 [ - + ]: 9 : if (pltcl_pm_init_done)
9544 bruce@momjian.us 407 :UBC 0 : return;
408 : :
5603 peter_e@gmx.net 409 :CBC 9 : pg_bindtextdomain(TEXTDOMAIN);
410 : :
411 : : #ifdef WIN32
412 : : /* Required on win32 to prevent error loading init.tcl */
413 : : Tcl_FindExecutable("");
414 : : #endif
415 : :
416 : : /*
417 : : * Override the functions in the Notifier subsystem. See comments above.
418 : : */
2965 tgl@sss.pgh.pa.us 419 : 9 : notifier.setTimerProc = pltcl_SetTimer;
420 : 9 : notifier.waitForEventProc = pltcl_WaitForEvent;
421 : 9 : notifier.createFileHandlerProc = pltcl_CreateFileHandler;
422 : 9 : notifier.deleteFileHandlerProc = pltcl_DeleteFileHandler;
423 : 9 : notifier.initNotifierProc = pltcl_InitNotifier;
424 : 9 : notifier.finalizeNotifierProc = pltcl_FinalizeNotifier;
425 : 9 : notifier.alertNotifierProc = pltcl_AlertNotifier;
426 : 9 : notifier.serviceModeHookProc = pltcl_ServiceModeHook;
427 : 9 : Tcl_SetNotifier(¬ifier);
428 : :
429 : : /************************************************************
430 : : * Create the dummy hold interpreter to prevent close of
431 : : * stdout and stderr on DeleteInterp
432 : : ************************************************************/
8670 JanWieck@Yahoo.com 433 [ - + ]: 9 : if ((pltcl_hold_interp = Tcl_CreateInterp()) == NULL)
1399 andres@anarazel.de 434 [ # # ]:UBC 0 : elog(ERROR, "could not create dummy Tcl interpreter");
5193 tgl@sss.pgh.pa.us 435 [ - + ]:CBC 9 : if (Tcl_Init(pltcl_hold_interp) == TCL_ERROR)
1399 andres@anarazel.de 436 [ # # ]:UBC 0 : elog(ERROR, "could not initialize dummy Tcl interpreter");
437 : :
438 : : /************************************************************
439 : : * Create the hash table for working interpreters
440 : : ************************************************************/
4945 tgl@sss.pgh.pa.us 441 :CBC 9 : hash_ctl.keysize = sizeof(Oid);
442 : 9 : hash_ctl.entrysize = sizeof(pltcl_interp_desc);
443 : 9 : pltcl_interp_htab = hash_create("PL/Tcl interpreters",
444 : : 8,
445 : : &hash_ctl,
446 : : HASH_ELEM | HASH_BLOBS);
447 : :
448 : : /************************************************************
449 : : * Create the hash table for function lookup
450 : : ************************************************************/
451 : 9 : hash_ctl.keysize = sizeof(pltcl_proc_key);
452 : 9 : hash_ctl.entrysize = sizeof(pltcl_proc_ptr);
453 : 9 : pltcl_proc_htab = hash_create("PL/Tcl functions",
454 : : 100,
455 : : &hash_ctl,
456 : : HASH_ELEM | HASH_BLOBS);
457 : :
458 : : /************************************************************
459 : : * Define PL/Tcl's custom GUCs
460 : : ************************************************************/
2595 461 : 9 : DefineCustomStringVariable("pltcl.start_proc",
462 : : gettext_noop("PL/Tcl function to call once when pltcl is first used."),
463 : : NULL,
464 : : &pltcl_start_proc,
465 : : NULL,
466 : : PGC_SUSET, 0,
467 : : NULL, NULL, NULL);
468 : 9 : DefineCustomStringVariable("pltclu.start_proc",
469 : : gettext_noop("PL/TclU function to call once when pltclu is first used."),
470 : : NULL,
471 : : &pltclu_start_proc,
472 : : NULL,
473 : : PGC_SUSET, 0,
474 : : NULL, NULL, NULL);
475 : :
783 476 : 9 : MarkGUCPrefixReserved("pltcl");
477 : 9 : MarkGUCPrefixReserved("pltclu");
478 : :
7563 479 : 9 : pltcl_pm_init_done = true;
480 : : }
481 : :
482 : : /**********************************************************************
483 : : * pltcl_init_interp() - initialize a new Tcl interpreter
484 : : **********************************************************************/
485 : : static void
2595 486 : 11 : pltcl_init_interp(pltcl_interp_desc *interp_desc, Oid prolang, bool pltrusted)
487 : : {
488 : : Tcl_Interp *interp;
489 : : char interpname[32];
490 : :
491 : : /************************************************************
492 : : * Create the Tcl interpreter subsidiary to pltcl_hold_interp.
493 : : * Note: Tcl automatically does Tcl_Init in the untrusted case,
494 : : * and it's not wanted in the trusted case.
495 : : ************************************************************/
1399 andres@anarazel.de 496 : 11 : snprintf(interpname, sizeof(interpname), "subsidiary_%u", interp_desc->user_id);
4945 tgl@sss.pgh.pa.us 497 [ - + ]: 11 : if ((interp = Tcl_CreateSlave(pltcl_hold_interp, interpname,
498 : : pltrusted ? 1 : 0)) == NULL)
1399 andres@anarazel.de 499 [ # # ]:UBC 0 : elog(ERROR, "could not create subsidiary Tcl interpreter");
500 : :
501 : : /************************************************************
502 : : * Initialize the query hash table associated with interpreter
503 : : ************************************************************/
4945 tgl@sss.pgh.pa.us 504 :CBC 11 : Tcl_InitHashTable(&interp_desc->query_hash, TCL_STRING_KEYS);
505 : :
506 : : /************************************************************
507 : : * Install the commands for SPI support in the interpreter
508 : : ************************************************************/
2965 509 : 11 : Tcl_CreateObjCommand(interp, "elog",
510 : : pltcl_elog, NULL, NULL);
511 : 11 : Tcl_CreateObjCommand(interp, "quote",
512 : : pltcl_quote, NULL, NULL);
513 : 11 : Tcl_CreateObjCommand(interp, "argisnull",
514 : : pltcl_argisnull, NULL, NULL);
515 : 11 : Tcl_CreateObjCommand(interp, "return_null",
516 : : pltcl_returnnull, NULL, NULL);
2716 517 : 11 : Tcl_CreateObjCommand(interp, "return_next",
518 : : pltcl_returnnext, NULL, NULL);
2965 519 : 11 : Tcl_CreateObjCommand(interp, "spi_exec",
520 : : pltcl_SPI_execute, NULL, NULL);
521 : 11 : Tcl_CreateObjCommand(interp, "spi_prepare",
522 : : pltcl_SPI_prepare, NULL, NULL);
523 : 11 : Tcl_CreateObjCommand(interp, "spi_execp",
524 : : pltcl_SPI_execute_plan, NULL, NULL);
2591 525 : 11 : Tcl_CreateObjCommand(interp, "subtransaction",
526 : : pltcl_subtransaction, NULL, NULL);
2274 peter_e@gmx.net 527 : 11 : Tcl_CreateObjCommand(interp, "commit",
528 : : pltcl_commit, NULL, NULL);
529 : 11 : Tcl_CreateObjCommand(interp, "rollback",
530 : : pltcl_rollback, NULL, NULL);
531 : :
532 : : /************************************************************
533 : : * Call the appropriate start_proc, if there is one.
534 : : *
535 : : * We must set interp_desc->interp before the call, else the start_proc
536 : : * won't find the interpreter it's supposed to use. But, if the
537 : : * start_proc fails, we want to abandon use of the interpreter.
538 : : ************************************************************/
2595 tgl@sss.pgh.pa.us 539 [ + + ]: 11 : PG_TRY();
540 : : {
541 : 11 : interp_desc->interp = interp;
542 : 11 : call_pltcl_start_proc(prolang, pltrusted);
543 : : }
544 : 3 : PG_CATCH();
545 : : {
546 : 3 : interp_desc->interp = NULL;
547 : 3 : Tcl_DeleteInterp(interp);
548 : 3 : PG_RE_THROW();
549 : : }
550 [ - + ]: 8 : PG_END_TRY();
9559 scrappy@hub.org 551 : 8 : }
552 : :
553 : : /**********************************************************************
554 : : * pltcl_fetch_interp() - fetch the Tcl interpreter to use for a function
555 : : *
556 : : * This also takes care of any on-first-use initialization required.
557 : : **********************************************************************/
558 : : static pltcl_interp_desc *
2595 tgl@sss.pgh.pa.us 559 : 60 : pltcl_fetch_interp(Oid prolang, bool pltrusted)
560 : : {
561 : : Oid user_id;
562 : : pltcl_interp_desc *interp_desc;
563 : : bool found;
564 : :
565 : : /* Find or create the interpreter hashtable entry for this userid */
5085 566 [ + - ]: 60 : if (pltrusted)
4945 567 : 60 : user_id = GetUserId();
568 : : else
4945 tgl@sss.pgh.pa.us 569 :UBC 0 : user_id = InvalidOid;
570 : :
4945 tgl@sss.pgh.pa.us 571 :CBC 60 : interp_desc = hash_search(pltcl_interp_htab, &user_id,
572 : : HASH_ENTER,
573 : : &found);
574 [ + + ]: 60 : if (!found)
2595 575 : 8 : interp_desc->interp = NULL;
576 : :
577 : : /* If we haven't yet successfully made an interpreter, try to do that */
578 [ + + ]: 60 : if (!interp_desc->interp)
579 : 11 : pltcl_init_interp(interp_desc, prolang, pltrusted);
580 : :
4945 581 : 57 : return interp_desc;
582 : : }
583 : :
584 : :
585 : : /**********************************************************************
586 : : * call_pltcl_start_proc() - Call user-defined initialization proc, if any
587 : : **********************************************************************/
588 : : static void
2595 589 : 11 : call_pltcl_start_proc(Oid prolang, bool pltrusted)
590 : : {
1905 andres@anarazel.de 591 : 11 : LOCAL_FCINFO(fcinfo, 0);
592 : : char *start_proc;
593 : : const char *gucname;
594 : : ErrorContextCallback errcallback;
595 : : List *namelist;
596 : : Oid procOid;
597 : : HeapTuple procTup;
598 : : Form_pg_proc procStruct;
599 : : AclResult aclresult;
600 : : FmgrInfo finfo;
601 : : PgStat_FunctionCallUsage fcusage;
602 : :
603 : : /* select appropriate GUC */
2595 tgl@sss.pgh.pa.us 604 [ + - ]: 11 : start_proc = pltrusted ? pltcl_start_proc : pltclu_start_proc;
605 [ + - ]: 11 : gucname = pltrusted ? "pltcl.start_proc" : "pltclu.start_proc";
606 : :
607 : : /* Nothing to do if it's empty or unset */
608 [ + + - + ]: 11 : if (start_proc == NULL || start_proc[0] == '\0')
609 : 7 : return;
610 : :
611 : : /* Set up errcontext callback to make errors more helpful */
612 : 4 : errcallback.callback = start_proc_error_callback;
1902 peter@eisentraut.org 613 : 4 : errcallback.arg = unconstify(char *, gucname);
2595 tgl@sss.pgh.pa.us 614 : 4 : errcallback.previous = error_context_stack;
615 : 4 : error_context_stack = &errcallback;
616 : :
617 : : /* Parse possibly-qualified identifier and look up the function */
474 618 : 4 : namelist = stringToQualifiedNameList(start_proc, NULL);
1615 alvherre@alvh.no-ip. 619 : 4 : procOid = LookupFuncName(namelist, 0, NULL, false);
620 : :
621 : : /* Current user must have permission to call function */
518 peter@eisentraut.org 622 : 2 : aclresult = object_aclcheck(ProcedureRelationId, procOid, GetUserId(), ACL_EXECUTE);
2595 tgl@sss.pgh.pa.us 623 [ - + ]: 2 : if (aclresult != ACLCHECK_OK)
2325 peter_e@gmx.net 624 :UBC 0 : aclcheck_error(aclresult, OBJECT_FUNCTION, start_proc);
625 : :
626 : : /* Get the function's pg_proc entry */
2595 tgl@sss.pgh.pa.us 627 :CBC 2 : procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procOid));
628 [ - + ]: 2 : if (!HeapTupleIsValid(procTup))
2595 tgl@sss.pgh.pa.us 629 [ # # ]:UBC 0 : elog(ERROR, "cache lookup failed for function %u", procOid);
2595 tgl@sss.pgh.pa.us 630 :CBC 2 : procStruct = (Form_pg_proc) GETSTRUCT(procTup);
631 : :
632 : : /* It must be same language as the function we're currently calling */
633 [ - + ]: 2 : if (procStruct->prolang != prolang)
2595 tgl@sss.pgh.pa.us 634 [ # # ]:UBC 0 : ereport(ERROR,
635 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
636 : : errmsg("function \"%s\" is in the wrong language",
637 : : start_proc)));
638 : :
639 : : /*
640 : : * It must not be SECURITY DEFINER, either. This together with the
641 : : * language match check ensures that the function will execute in the same
642 : : * Tcl interpreter we just finished initializing.
643 : : */
2595 tgl@sss.pgh.pa.us 644 [ + + ]:CBC 2 : if (procStruct->prosecdef)
645 [ + - ]: 1 : ereport(ERROR,
646 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
647 : : errmsg("function \"%s\" must not be SECURITY DEFINER",
648 : : start_proc)));
649 : :
650 : : /* A-OK */
651 : 1 : ReleaseSysCache(procTup);
652 : :
653 : : /*
654 : : * Call the function using the normal SQL function call mechanism. We
655 : : * could perhaps cheat and jump directly to pltcl_handler(), but it seems
656 : : * better to do it this way so that the call is exposed to, eg, call
657 : : * statistics collection.
658 : : */
659 [ - + ]: 1 : InvokeFunctionExecuteHook(procOid);
660 : 1 : fmgr_info(procOid, &finfo);
1905 andres@anarazel.de 661 : 1 : InitFunctionCallInfoData(*fcinfo, &finfo,
662 : : 0,
663 : : InvalidOid, NULL, NULL);
664 : 1 : pgstat_init_function_usage(fcinfo, &fcusage);
665 : 1 : (void) FunctionCallInvoke(fcinfo);
2595 tgl@sss.pgh.pa.us 666 : 1 : pgstat_end_function_usage(&fcusage, true);
667 : :
668 : : /* Pop the error context stack */
669 : 1 : error_context_stack = errcallback.previous;
670 : : }
671 : :
672 : : /*
673 : : * Error context callback for errors occurring during start_proc processing.
674 : : */
675 : : static void
676 : 4 : start_proc_error_callback(void *arg)
677 : : {
678 : 4 : const char *gucname = (const char *) arg;
679 : :
680 : : /* translator: %s is "pltcl.start_proc" or "pltclu.start_proc" */
681 : 4 : errcontext("processing %s parameter", gucname);
682 : 4 : }
683 : :
684 : :
685 : : /**********************************************************************
686 : : * pltcl_call_handler - This is the only visible function
687 : : * of the PL interpreter. The PostgreSQL
688 : : * function manager and trigger manager
689 : : * call this function for execution of
690 : : * PL/Tcl procedures.
691 : : **********************************************************************/
8546 692 : 9 : PG_FUNCTION_INFO_V1(pltcl_call_handler);
693 : :
694 : : /* keep non-static */
695 : : Datum
8722 696 : 216 : pltcl_call_handler(PG_FUNCTION_ARGS)
697 : : {
4945 698 : 216 : return pltcl_handler(fcinfo, true);
699 : : }
700 : :
701 : : /*
702 : : * Alternative handler for unsafe functions
703 : : */
4945 tgl@sss.pgh.pa.us 704 :UBC 0 : PG_FUNCTION_INFO_V1(pltclu_call_handler);
705 : :
706 : : /* keep non-static */
707 : : Datum
708 : 0 : pltclu_call_handler(PG_FUNCTION_ARGS)
709 : : {
710 : 0 : return pltcl_handler(fcinfo, false);
711 : : }
712 : :
713 : :
714 : : /**********************************************************************
715 : : * pltcl_handler() - Handler for function and trigger calls, for
716 : : * both trusted and untrusted interpreters.
717 : : **********************************************************************/
718 : : static Datum
4945 tgl@sss.pgh.pa.us 719 :CBC 216 : pltcl_handler(PG_FUNCTION_ARGS, bool pltrusted)
720 : : {
1623 peter@eisentraut.org 721 : 216 : Datum retval = (Datum) 0;
722 : : pltcl_call_state current_call_state;
723 : : pltcl_call_state *save_call_state;
724 : :
725 : : /*
726 : : * Initialize current_call_state to nulls/zeroes; in particular, set its
727 : : * prodesc pointer to null. Anything that sets it non-null should
728 : : * increase the prodesc's fn_refcount at the same time. We'll decrease
729 : : * the refcount, and then delete the prodesc if it's no longer referenced,
730 : : * on the way out of this function. This ensures that prodescs live as
731 : : * long as needed even if somebody replaces the originating pg_proc row
732 : : * while they're executing.
733 : : */
2716 tgl@sss.pgh.pa.us 734 : 216 : memset(¤t_call_state, 0, sizeof(current_call_state));
735 : :
736 : : /*
737 : : * Ensure that static pointer is saved/restored properly
738 : : */
739 : 216 : save_call_state = pltcl_current_call_state;
740 : 216 : pltcl_current_call_state = ¤t_call_state;
741 : :
7153 742 [ + + ]: 216 : PG_TRY();
743 : : {
744 : : /*
745 : : * Determine if called as function or trigger and call appropriate
746 : : * subhandler
747 : : */
748 [ + + + + ]: 216 : if (CALLED_AS_TRIGGER(fcinfo))
749 : : {
750 : : /* invoke the trigger handler */
2716 751 : 58 : retval = PointerGetDatum(pltcl_trigger_handler(fcinfo,
752 : : ¤t_call_state,
753 : : pltrusted));
754 : : }
3795 peter_e@gmx.net 755 [ + + + + ]: 158 : else if (CALLED_AS_EVENT_TRIGGER(fcinfo))
756 : : {
757 : : /* invoke the event trigger handler */
2716 tgl@sss.pgh.pa.us 758 : 10 : pltcl_event_trigger_handler(fcinfo, ¤t_call_state, pltrusted);
3795 peter_e@gmx.net 759 : 10 : retval = (Datum) 0;
760 : : }
761 : : else
762 : : {
763 : : /* invoke the regular function handler */
2716 tgl@sss.pgh.pa.us 764 : 148 : current_call_state.fcinfo = fcinfo;
765 : 148 : retval = pltcl_func_handler(fcinfo, ¤t_call_state, pltrusted);
766 : : }
767 : : }
1626 peter@eisentraut.org 768 : 54 : PG_FINALLY();
769 : : {
770 : : /* Restore static pointer, then clean up the prodesc refcount if any */
771 : : /*
772 : : * (We're being paranoid in case an error is thrown in context
773 : : * deletion)
774 : : */
2716 tgl@sss.pgh.pa.us 775 : 216 : pltcl_current_call_state = save_call_state;
776 [ + + ]: 216 : if (current_call_state.prodesc != NULL)
777 : : {
778 [ - + ]: 213 : Assert(current_call_state.prodesc->fn_refcount > 0);
779 [ - + ]: 213 : if (--current_call_state.prodesc->fn_refcount == 0)
2716 tgl@sss.pgh.pa.us 780 :UBC 0 : MemoryContextDelete(current_call_state.prodesc->fn_cxt);
781 : : }
782 : : }
7153 tgl@sss.pgh.pa.us 783 [ + + ]:CBC 216 : PG_END_TRY();
784 : :
9544 bruce@momjian.us 785 : 162 : return retval;
786 : : }
787 : :
788 : :
789 : : /**********************************************************************
790 : : * pltcl_func_handler() - Handler for regular function calls
791 : : **********************************************************************/
792 : : static Datum
2716 tgl@sss.pgh.pa.us 793 : 148 : pltcl_func_handler(PG_FUNCTION_ARGS, pltcl_call_state *call_state,
794 : : bool pltrusted)
795 : : {
796 : : bool nonatomic;
797 : : pltcl_proc_desc *prodesc;
798 : : Tcl_Interp *volatile interp;
799 : : Tcl_Obj *tcl_cmd;
800 : : int i;
801 : : int tcl_rc;
802 : : Datum retval;
803 : :
2274 peter_e@gmx.net 804 : 331 : nonatomic = fcinfo->context &&
805 [ + + + + ]: 160 : IsA(fcinfo->context, CallContext) &&
806 [ + + ]: 12 : !castNode(CallContext, fcinfo->context)->atomic;
807 : :
808 : : /* Connect to SPI manager */
809 [ - + ]: 148 : if (SPI_connect_ext(nonatomic ? SPI_OPT_NONATOMIC : 0) != SPI_OK_CONNECT)
7197 tgl@sss.pgh.pa.us 810 [ # # ]:UBC 0 : elog(ERROR, "could not connect to SPI manager");
811 : :
812 : : /* Find or compile the function */
4945 tgl@sss.pgh.pa.us 813 :CBC 148 : prodesc = compile_pltcl_function(fcinfo->flinfo->fn_oid, InvalidOid,
814 : : false, pltrusted);
815 : :
2716 816 : 145 : call_state->prodesc = prodesc;
2783 817 : 145 : prodesc->fn_refcount++;
818 : :
4945 819 : 145 : interp = prodesc->interp_desc->interp;
820 : :
821 : : /*
822 : : * If we're a SRF, check caller can handle materialize mode, and save
823 : : * relevant info into call_state. We must ensure that the returned
824 : : * tuplestore is owned by the caller's context, even if we first create it
825 : : * inside a subtransaction.
826 : : */
2716 827 [ + + ]: 145 : if (prodesc->fn_retisset)
828 : : {
829 : 5 : ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
830 : :
780 michael@paquier.xyz 831 [ + - - + ]: 5 : if (!rsi || !IsA(rsi, ReturnSetInfo))
2716 tgl@sss.pgh.pa.us 832 [ # # ]:UBC 0 : ereport(ERROR,
833 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
834 : : errmsg("set-valued function called in context that cannot accept a set")));
835 : :
780 michael@paquier.xyz 836 [ - + ]:CBC 5 : if (!(rsi->allowedModes & SFRM_Materialize))
780 michael@paquier.xyz 837 [ # # ]:UBC 0 : ereport(ERROR,
838 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
839 : : errmsg("materialize mode required, but it is not allowed in this context")));
840 : :
2716 tgl@sss.pgh.pa.us 841 :CBC 5 : call_state->rsi = rsi;
842 : 5 : call_state->tuple_store_cxt = rsi->econtext->ecxt_per_query_memory;
843 : 5 : call_state->tuple_store_owner = CurrentResourceOwner;
844 : : }
845 : :
846 : : /************************************************************
847 : : * Create the tcl command to call the internal
848 : : * proc in the Tcl interpreter
849 : : ************************************************************/
2965 850 : 145 : tcl_cmd = Tcl_NewObj();
851 : 145 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
852 : 145 : Tcl_NewStringObj(prodesc->internal_proname, -1));
853 : :
854 : : /* We hold a refcount on tcl_cmd just to be sure it stays around */
855 : 145 : Tcl_IncrRefCount(tcl_cmd);
856 : :
857 : : /************************************************************
858 : : * Add all call arguments to the command
859 : : ************************************************************/
7197 860 [ + - ]: 145 : PG_TRY();
861 : : {
7168 bruce@momjian.us 862 [ + + ]: 336 : for (i = 0; i < prodesc->nargs; i++)
863 : : {
864 [ + + ]: 191 : if (prodesc->arg_is_rowtype[i])
865 : : {
866 : : /**************************************************
867 : : * For tuple values, add a list for 'array set ...'
868 : : **************************************************/
1905 andres@anarazel.de 869 [ - + ]: 7 : if (fcinfo->args[i].isnull)
2965 tgl@sss.pgh.pa.us 870 :UBC 0 : Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
871 : : else
872 : : {
873 : : HeapTupleHeader td;
874 : : Oid tupType;
875 : : int32 tupTypmod;
876 : : TupleDesc tupdesc;
877 : : HeapTupleData tmptup;
878 : : Tcl_Obj *list_tmp;
879 : :
1905 andres@anarazel.de 880 :CBC 7 : td = DatumGetHeapTupleHeader(fcinfo->args[i].value);
881 : : /* Extract rowtype info and find a tupdesc */
7168 bruce@momjian.us 882 : 7 : tupType = HeapTupleHeaderGetTypeId(td);
883 : 7 : tupTypmod = HeapTupleHeaderGetTypMod(td);
884 : 7 : tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
885 : : /* Build a temporary HeapTuple control structure */
886 : 7 : tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
887 : 7 : tmptup.t_data = td;
888 : :
1842 peter@eisentraut.org 889 : 7 : list_tmp = pltcl_build_tuple_argument(&tmptup, tupdesc, true);
2965 tgl@sss.pgh.pa.us 890 : 7 : Tcl_ListObjAppendElement(NULL, tcl_cmd, list_tmp);
891 : :
6512 892 [ + - ]: 7 : ReleaseTupleDesc(tupdesc);
893 : : }
894 : : }
895 : : else
896 : : {
897 : : /**************************************************
898 : : * Single values are added as string element
899 : : * of their external representation
900 : : **************************************************/
1905 andres@anarazel.de 901 [ + + ]: 184 : if (fcinfo->args[i].isnull)
2965 tgl@sss.pgh.pa.us 902 : 2 : Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
903 : : else
904 : : {
905 : : char *tmp;
906 : :
6585 907 : 182 : tmp = OutputFunctionCall(&prodesc->arg_out_func[i],
908 : : fcinfo->args[i].value);
7168 bruce@momjian.us 909 : 182 : UTF_BEGIN;
2965 tgl@sss.pgh.pa.us 910 : 182 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
2489 911 : 182 : Tcl_NewStringObj(UTF_E2U(tmp), -1));
7168 bruce@momjian.us 912 [ - + ]: 182 : UTF_END;
913 : 182 : pfree(tmp);
914 : : }
915 : : }
916 : : }
917 : : }
7197 tgl@sss.pgh.pa.us 918 :UBC 0 : PG_CATCH();
919 : : {
920 : : /* Release refcount to free tcl_cmd */
2965 921 [ # # ]: 0 : Tcl_DecrRefCount(tcl_cmd);
7197 922 : 0 : PG_RE_THROW();
923 : : }
7197 tgl@sss.pgh.pa.us 924 [ - + ]:CBC 145 : PG_END_TRY();
925 : :
926 : : /************************************************************
927 : : * Call the Tcl function
928 : : *
929 : : * We assume no PG error can be thrown directly from this call.
930 : : ************************************************************/
2965 931 : 145 : tcl_rc = Tcl_EvalObjEx(interp, tcl_cmd, (TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL));
932 : :
933 : : /* Release refcount to free tcl_cmd (and all subsidiary objects) */
934 [ + - ]: 145 : Tcl_DecrRefCount(tcl_cmd);
935 : :
936 : : /************************************************************
937 : : * Check for errors reported by Tcl.
938 : : ************************************************************/
7197 939 [ + + ]: 145 : if (tcl_rc != TCL_OK)
5780 940 : 38 : throw_tcl_error(interp, prodesc->user_proname);
941 : :
942 : : /************************************************************
943 : : * Disconnect from SPI manager and then create the return
944 : : * value datum (if the input function does a palloc for it
945 : : * this must not be allocated in the SPI memory context
946 : : * because SPI_finish would free it). But don't try to call
947 : : * the result_in_func if we've been told to return a NULL;
948 : : * the Tcl result may not be a valid value of the result type
949 : : * in that case.
950 : : ************************************************************/
9319 bruce@momjian.us 951 [ - + ]: 107 : if (SPI_finish() != SPI_OK_FINISH)
7569 tgl@sss.pgh.pa.us 952 [ # # ]:UBC 0 : elog(ERROR, "SPI_finish() failed");
953 : :
2716 tgl@sss.pgh.pa.us 954 [ + + ]:CBC 107 : if (prodesc->fn_retisset)
955 : : {
956 : 3 : ReturnSetInfo *rsi = call_state->rsi;
957 : :
958 : : /* We already checked this is OK */
959 : 3 : rsi->returnMode = SFRM_Materialize;
960 : :
961 : : /* If we produced any tuples, send back the result */
962 [ + - ]: 3 : if (call_state->tuple_store)
963 : : {
964 : 3 : rsi->setResult = call_state->tuple_store;
965 [ + - ]: 3 : if (call_state->ret_tupdesc)
966 : : {
967 : : MemoryContext oldcxt;
968 : :
969 : 3 : oldcxt = MemoryContextSwitchTo(call_state->tuple_store_cxt);
970 : 3 : rsi->setDesc = CreateTupleDescCopy(call_state->ret_tupdesc);
971 : 3 : MemoryContextSwitchTo(oldcxt);
972 : : }
973 : : }
974 : 3 : retval = (Datum) 0;
975 : 3 : fcinfo->isnull = true;
976 : : }
2232 peter_e@gmx.net 977 [ + + ]: 104 : else if (fcinfo->isnull)
978 : : {
6585 tgl@sss.pgh.pa.us 979 : 1 : retval = InputFunctionCall(&prodesc->result_in_func,
980 : : NULL,
981 : : prodesc->result_typioparam,
982 : : -1);
983 : : }
2716 984 [ + + ]: 103 : else if (prodesc->fn_retistuple)
985 : : {
986 : : TupleDesc td;
987 : : HeapTuple tup;
988 : : Tcl_Obj *resultObj;
989 : : Tcl_Obj **resultObjv;
990 : : int resultObjc;
991 : :
992 : : /*
993 : : * Set up data about result type. XXX it's tempting to consider
994 : : * caching this in the prodesc, in the common case where the rowtype
995 : : * is determined by the function not the calling query. But we'd have
996 : : * to be able to deal with ADD/DROP/ALTER COLUMN events when the
997 : : * result type is a named composite type, so it's not exactly trivial.
998 : : * Maybe worth improving someday.
999 : : */
2362 1000 [ + + + - ]: 15 : switch (get_call_result_type(fcinfo, NULL, &td))
1001 : : {
1002 : 11 : case TYPEFUNC_COMPOSITE:
1003 : : /* success */
1004 : 11 : break;
1005 : 3 : case TYPEFUNC_COMPOSITE_DOMAIN:
1006 [ - + ]: 3 : Assert(prodesc->fn_retisdomain);
1007 : 3 : break;
1008 : 1 : case TYPEFUNC_RECORD:
1009 : : /* failed to determine actual type of RECORD */
1010 [ + - ]: 1 : ereport(ERROR,
1011 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1012 : : errmsg("function returning record called in context "
1013 : : "that cannot accept type record")));
1014 : : break;
2362 tgl@sss.pgh.pa.us 1015 :UBC 0 : default:
1016 : : /* result type isn't composite? */
1017 [ # # ]: 0 : elog(ERROR, "return type must be a row type");
1018 : : break;
1019 : : }
1020 : :
2716 tgl@sss.pgh.pa.us 1021 [ - + ]:CBC 14 : Assert(!call_state->ret_tupdesc);
1022 [ - + ]: 14 : Assert(!call_state->attinmeta);
1023 : 14 : call_state->ret_tupdesc = td;
1024 : 14 : call_state->attinmeta = TupleDescGetAttInMetadata(td);
1025 : :
1026 : : /* Convert function result to tuple */
1027 : 14 : resultObj = Tcl_GetObjResult(interp);
1028 [ - + ]: 14 : if (Tcl_ListObjGetElements(interp, resultObj, &resultObjc, &resultObjv) == TCL_ERROR)
2716 tgl@sss.pgh.pa.us 1029 :UBC 0 : throw_tcl_error(interp, prodesc->user_proname);
1030 : :
2716 tgl@sss.pgh.pa.us 1031 :CBC 14 : tup = pltcl_build_tuple_result(interp, resultObjv, resultObjc,
1032 : : call_state);
1033 : 10 : retval = HeapTupleGetDatum(tup);
1034 : : }
1035 : : else
6585 1036 : 88 : retval = InputFunctionCall(&prodesc->result_in_func,
1037 : : utf_u2e(Tcl_GetStringResult(interp)),
1038 : : prodesc->result_typioparam,
1039 : : -1);
1040 : :
9544 bruce@momjian.us 1041 : 102 : return retval;
1042 : : }
1043 : :
1044 : :
1045 : : /**********************************************************************
1046 : : * pltcl_trigger_handler() - Handler for trigger calls
1047 : : **********************************************************************/
1048 : : static HeapTuple
2716 tgl@sss.pgh.pa.us 1049 : 58 : pltcl_trigger_handler(PG_FUNCTION_ARGS, pltcl_call_state *call_state,
1050 : : bool pltrusted)
1051 : : {
1052 : : pltcl_proc_desc *prodesc;
1053 : : Tcl_Interp *volatile interp;
8721 1054 : 58 : TriggerData *trigdata = (TriggerData *) fcinfo->context;
1055 : : char *stroid;
1056 : : TupleDesc tupdesc;
1057 : : volatile HeapTuple rettup;
1058 : : Tcl_Obj *tcl_cmd;
1059 : : Tcl_Obj *tcl_trigtup;
1060 : : int tcl_rc;
1061 : : int i;
1062 : : const char *result;
1063 : : int result_Objc;
1064 : : Tcl_Obj **result_Objv;
1065 : : int rc PG_USED_FOR_ASSERTS_ONLY;
1066 : :
2655 1067 : 58 : call_state->trigdata = trigdata;
1068 : :
1069 : : /* Connect to SPI manager */
7197 1070 [ - + ]: 58 : if (SPI_connect() != SPI_OK_CONNECT)
7197 tgl@sss.pgh.pa.us 1071 [ # # ]:UBC 0 : elog(ERROR, "could not connect to SPI manager");
1072 : :
1073 : : /* Make transition tables visible to this SPI connection */
2567 kgrittn@postgresql.o 1074 :CBC 58 : rc = SPI_register_trigger_data(trigdata);
1075 [ - + ]: 58 : Assert(rc >= 0);
1076 : :
1077 : : /* Find or compile the function */
7518 tgl@sss.pgh.pa.us 1078 : 116 : prodesc = compile_pltcl_function(fcinfo->flinfo->fn_oid,
4945 1079 : 58 : RelationGetRelid(trigdata->tg_relation),
1080 : : false, /* not an event trigger */
1081 : : pltrusted);
1082 : :
2716 1083 : 58 : call_state->prodesc = prodesc;
2783 1084 : 58 : prodesc->fn_refcount++;
1085 : :
4945 1086 : 58 : interp = prodesc->interp_desc->interp;
1087 : :
2655 1088 : 58 : tupdesc = RelationGetDescr(trigdata->tg_relation);
1089 : :
1090 : : /************************************************************
1091 : : * Create the tcl command to call the internal
1092 : : * proc in the interpreter
1093 : : ************************************************************/
2965 1094 : 58 : tcl_cmd = Tcl_NewObj();
1095 : 58 : Tcl_IncrRefCount(tcl_cmd);
1096 : :
7197 1097 [ + - ]: 58 : PG_TRY();
1098 : : {
1099 : : /* The procedure name (note this is all ASCII, so no utf_e2u) */
2965 1100 : 58 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
2489 1101 : 58 : Tcl_NewStringObj(prodesc->internal_proname, -1));
1102 : :
1103 : : /* The trigger name for argument TG_name */
2965 1104 : 58 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
2489 1105 : 58 : Tcl_NewStringObj(utf_e2u(trigdata->tg_trigger->tgname), -1));
1106 : :
1107 : : /* The oid of the trigger relation for argument TG_relid */
1108 : : /* Consider not converting to a string for more performance? */
7168 bruce@momjian.us 1109 : 58 : stroid = DatumGetCString(DirectFunctionCall1(oidout,
1110 : : ObjectIdGetDatum(trigdata->tg_relation->rd_id)));
2965 tgl@sss.pgh.pa.us 1111 : 58 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1112 : : Tcl_NewStringObj(stroid, -1));
7168 bruce@momjian.us 1113 : 58 : pfree(stroid);
1114 : :
1115 : : /* The name of the table the trigger is acting on: TG_table_name */
6402 1116 : 58 : stroid = SPI_getrelname(trigdata->tg_relation);
2965 tgl@sss.pgh.pa.us 1117 : 58 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1118 : 58 : Tcl_NewStringObj(utf_e2u(stroid), -1));
6402 bruce@momjian.us 1119 : 58 : pfree(stroid);
1120 : :
1121 : : /* The schema of the table the trigger is acting on: TG_table_schema */
1122 : 58 : stroid = SPI_getnspname(trigdata->tg_relation);
2965 tgl@sss.pgh.pa.us 1123 : 58 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1124 : 58 : Tcl_NewStringObj(utf_e2u(stroid), -1));
6402 bruce@momjian.us 1125 : 58 : pfree(stroid);
1126 : :
1127 : : /* A list of attribute names for argument TG_relatts */
2965 tgl@sss.pgh.pa.us 1128 : 58 : tcl_trigtup = Tcl_NewObj();
1129 : 58 : Tcl_ListObjAppendElement(NULL, tcl_trigtup, Tcl_NewObj());
7168 bruce@momjian.us 1130 [ + + ]: 258 : for (i = 0; i < tupdesc->natts; i++)
1131 : : {
2429 andres@anarazel.de 1132 : 200 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
1133 : :
1134 [ + + ]: 200 : if (att->attisdropped)
2965 tgl@sss.pgh.pa.us 1135 : 13 : Tcl_ListObjAppendElement(NULL, tcl_trigtup, Tcl_NewObj());
1136 : : else
1137 : 187 : Tcl_ListObjAppendElement(NULL, tcl_trigtup,
2429 andres@anarazel.de 1138 : 187 : Tcl_NewStringObj(utf_e2u(NameStr(att->attname)), -1));
1139 : : }
2965 tgl@sss.pgh.pa.us 1140 : 58 : Tcl_ListObjAppendElement(NULL, tcl_cmd, tcl_trigtup);
1141 : :
1142 : : /* The when part of the event for TG_when */
7168 bruce@momjian.us 1143 [ + + ]: 58 : if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
2965 tgl@sss.pgh.pa.us 1144 : 47 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1145 : : Tcl_NewStringObj("BEFORE", -1));
7168 bruce@momjian.us 1146 [ + + ]: 11 : else if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
2965 tgl@sss.pgh.pa.us 1147 : 8 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1148 : : Tcl_NewStringObj("AFTER", -1));
4935 1149 [ + - ]: 3 : else if (TRIGGER_FIRED_INSTEAD(trigdata->tg_event))
2965 1150 : 3 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1151 : : Tcl_NewStringObj("INSTEAD OF", -1));
1152 : : else
7168 bruce@momjian.us 1153 [ # # ]:UBC 0 : elog(ERROR, "unrecognized WHEN tg_event: %u", trigdata->tg_event);
1154 : :
1155 : : /* The level part of the event for TG_level */
7168 bruce@momjian.us 1156 [ + + ]:CBC 58 : if (TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
1157 : : {
2965 tgl@sss.pgh.pa.us 1158 : 50 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1159 : : Tcl_NewStringObj("ROW", -1));
1160 : :
1161 : : /*
1162 : : * Now the command part of the event for TG_op and data for NEW
1163 : : * and OLD
1164 : : *
1165 : : * Note: In BEFORE trigger, stored generated columns are not
1166 : : * computed yet, so don't make them accessible in NEW row.
1167 : : */
7168 bruce@momjian.us 1168 [ + + ]: 50 : if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
1169 : : {
2965 tgl@sss.pgh.pa.us 1170 : 30 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1171 : : Tcl_NewStringObj("INSERT", -1));
1172 : :
1842 peter@eisentraut.org 1173 : 30 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1174 : : pltcl_build_tuple_argument(trigdata->tg_trigtuple,
1175 : : tupdesc,
1176 : 30 : !TRIGGER_FIRED_BEFORE(trigdata->tg_event)));
2965 tgl@sss.pgh.pa.us 1177 : 30 : Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1178 : :
7168 bruce@momjian.us 1179 : 30 : rettup = trigdata->tg_trigtuple;
1180 : : }
1181 [ + + ]: 20 : else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
1182 : : {
2965 tgl@sss.pgh.pa.us 1183 : 8 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1184 : : Tcl_NewStringObj("DELETE", -1));
1185 : :
1186 : 8 : Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1842 peter@eisentraut.org 1187 : 8 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1188 : : pltcl_build_tuple_argument(trigdata->tg_trigtuple,
1189 : : tupdesc,
1190 : : true));
1191 : :
7168 bruce@momjian.us 1192 : 8 : rettup = trigdata->tg_trigtuple;
1193 : : }
1194 [ + - ]: 12 : else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
1195 : : {
2965 tgl@sss.pgh.pa.us 1196 : 12 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1197 : : Tcl_NewStringObj("UPDATE", -1));
1198 : :
1842 peter@eisentraut.org 1199 : 12 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1200 : : pltcl_build_tuple_argument(trigdata->tg_newtuple,
1201 : : tupdesc,
1202 : 12 : !TRIGGER_FIRED_BEFORE(trigdata->tg_event)));
1203 : 12 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1204 : : pltcl_build_tuple_argument(trigdata->tg_trigtuple,
1205 : : tupdesc,
1206 : : true));
1207 : :
7168 bruce@momjian.us 1208 : 12 : rettup = trigdata->tg_newtuple;
1209 : : }
1210 : : else
7168 bruce@momjian.us 1211 [ # # ]:UBC 0 : elog(ERROR, "unrecognized OP tg_event: %u", trigdata->tg_event);
1212 : : }
7168 bruce@momjian.us 1213 [ + - ]:CBC 8 : else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
1214 : : {
2965 tgl@sss.pgh.pa.us 1215 : 8 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1216 : : Tcl_NewStringObj("STATEMENT", -1));
1217 : :
7168 bruce@momjian.us 1218 [ + + ]: 8 : if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
2965 tgl@sss.pgh.pa.us 1219 : 3 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1220 : : Tcl_NewStringObj("INSERT", -1));
7168 bruce@momjian.us 1221 [ + + ]: 5 : else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
2965 tgl@sss.pgh.pa.us 1222 : 1 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1223 : : Tcl_NewStringObj("DELETE", -1));
7168 bruce@momjian.us 1224 [ + + ]: 4 : else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
2965 tgl@sss.pgh.pa.us 1225 : 3 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1226 : : Tcl_NewStringObj("UPDATE", -1));
5861 1227 [ + - ]: 1 : else if (TRIGGER_FIRED_BY_TRUNCATE(trigdata->tg_event))
2965 1228 : 1 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1229 : : Tcl_NewStringObj("TRUNCATE", -1));
1230 : : else
7168 bruce@momjian.us 1231 [ # # ]:UBC 0 : elog(ERROR, "unrecognized OP tg_event: %u", trigdata->tg_event);
1232 : :
2965 tgl@sss.pgh.pa.us 1233 :CBC 8 : Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1234 : 8 : Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1235 : :
7168 bruce@momjian.us 1236 : 8 : rettup = (HeapTuple) NULL;
1237 : : }
1238 : : else
7168 bruce@momjian.us 1239 [ # # ]:UBC 0 : elog(ERROR, "unrecognized LEVEL tg_event: %u", trigdata->tg_event);
1240 : :
1241 : : /* Finally append the arguments from CREATE TRIGGER */
7168 bruce@momjian.us 1242 [ + + ]:CBC 135 : for (i = 0; i < trigdata->tg_trigger->tgnargs; i++)
2965 tgl@sss.pgh.pa.us 1243 : 77 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
2489 1244 : 77 : Tcl_NewStringObj(utf_e2u(trigdata->tg_trigger->tgargs[i]), -1));
1245 : : }
7197 tgl@sss.pgh.pa.us 1246 :UBC 0 : PG_CATCH();
1247 : : {
2965 1248 [ # # ]: 0 : Tcl_DecrRefCount(tcl_cmd);
7197 1249 : 0 : PG_RE_THROW();
1250 : : }
7197 tgl@sss.pgh.pa.us 1251 [ - + ]:CBC 58 : PG_END_TRY();
1252 : :
1253 : : /************************************************************
1254 : : * Call the Tcl function
1255 : : *
1256 : : * We assume no PG error can be thrown directly from this call.
1257 : : ************************************************************/
2965 1258 : 58 : tcl_rc = Tcl_EvalObjEx(interp, tcl_cmd, (TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL));
1259 : :
1260 : : /* Release refcount to free tcl_cmd (and all subsidiary objects) */
1261 [ + - ]: 58 : Tcl_DecrRefCount(tcl_cmd);
1262 : :
1263 : : /************************************************************
1264 : : * Check for errors reported by Tcl.
1265 : : ************************************************************/
7197 1266 [ + + ]: 58 : if (tcl_rc != TCL_OK)
5780 1267 : 7 : throw_tcl_error(interp, prodesc->user_proname);
1268 : :
1269 : : /************************************************************
1270 : : * Exit SPI environment.
1271 : : ************************************************************/
9319 bruce@momjian.us 1272 [ - + ]: 51 : if (SPI_finish() != SPI_OK_FINISH)
7569 tgl@sss.pgh.pa.us 1273 [ # # ]:UBC 0 : elog(ERROR, "SPI_finish() failed");
1274 : :
1275 : : /************************************************************
1276 : : * The return value from the procedure might be one of
1277 : : * the magic strings OK or SKIP, or a list from array get.
1278 : : * We can check for OK or SKIP without worrying about encoding.
1279 : : ************************************************************/
5780 tgl@sss.pgh.pa.us 1280 :CBC 51 : result = Tcl_GetStringResult(interp);
1281 : :
1282 [ + + ]: 51 : if (strcmp(result, "OK") == 0)
9544 bruce@momjian.us 1283 : 40 : return rettup;
5780 tgl@sss.pgh.pa.us 1284 [ + + ]: 11 : if (strcmp(result, "SKIP") == 0)
8116 1285 : 1 : return (HeapTuple) NULL;
1286 : :
1287 : : /************************************************************
1288 : : * Otherwise, the return value should be a column name/value list
1289 : : * specifying the modified tuple to return.
1290 : : ************************************************************/
2716 1291 [ - + ]: 10 : if (Tcl_ListObjGetElements(interp, Tcl_GetObjResult(interp),
1292 : : &result_Objc, &result_Objv) != TCL_OK)
3178 tgl@sss.pgh.pa.us 1293 [ # # ]:UBC 0 : ereport(ERROR,
1294 : : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
1295 : : errmsg("could not split return value from trigger: %s",
1296 : : utf_u2e(Tcl_GetStringResult(interp)))));
1297 : :
1298 : : /* Convert function result to tuple */
2655 tgl@sss.pgh.pa.us 1299 :CBC 10 : rettup = pltcl_build_tuple_result(interp, result_Objv, result_Objc,
1300 : : call_state);
1301 : :
9544 bruce@momjian.us 1302 : 9 : return rettup;
1303 : : }
1304 : :
1305 : : /**********************************************************************
1306 : : * pltcl_event_trigger_handler() - Handler for event trigger calls
1307 : : **********************************************************************/
1308 : : static void
2716 tgl@sss.pgh.pa.us 1309 : 10 : pltcl_event_trigger_handler(PG_FUNCTION_ARGS, pltcl_call_state *call_state,
1310 : : bool pltrusted)
1311 : : {
1312 : : pltcl_proc_desc *prodesc;
1313 : : Tcl_Interp *volatile interp;
3795 peter_e@gmx.net 1314 : 10 : EventTriggerData *tdata = (EventTriggerData *) fcinfo->context;
1315 : : Tcl_Obj *tcl_cmd;
1316 : : int tcl_rc;
1317 : :
1318 : : /* Connect to SPI manager */
1319 [ - + ]: 10 : if (SPI_connect() != SPI_OK_CONNECT)
3795 peter_e@gmx.net 1320 [ # # ]:UBC 0 : elog(ERROR, "could not connect to SPI manager");
1321 : :
1322 : : /* Find or compile the function */
3795 peter_e@gmx.net 1323 :CBC 10 : prodesc = compile_pltcl_function(fcinfo->flinfo->fn_oid,
1324 : : InvalidOid, true, pltrusted);
1325 : :
2716 tgl@sss.pgh.pa.us 1326 : 10 : call_state->prodesc = prodesc;
2783 1327 : 10 : prodesc->fn_refcount++;
1328 : :
3795 peter_e@gmx.net 1329 : 10 : interp = prodesc->interp_desc->interp;
1330 : :
1331 : : /* Create the tcl command and call the internal proc */
2965 tgl@sss.pgh.pa.us 1332 : 10 : tcl_cmd = Tcl_NewObj();
1333 : 10 : Tcl_IncrRefCount(tcl_cmd);
1334 : 10 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1335 : 10 : Tcl_NewStringObj(prodesc->internal_proname, -1));
1336 : 10 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1337 : 10 : Tcl_NewStringObj(utf_e2u(tdata->event), -1));
1338 : 10 : Tcl_ListObjAppendElement(NULL, tcl_cmd,
1504 alvherre@alvh.no-ip. 1339 : 10 : Tcl_NewStringObj(utf_e2u(GetCommandTagName(tdata->tag)),
1340 : : -1));
1341 : :
2965 tgl@sss.pgh.pa.us 1342 : 10 : tcl_rc = Tcl_EvalObjEx(interp, tcl_cmd, (TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL));
1343 : :
1344 : : /* Release refcount to free tcl_cmd (and all subsidiary objects) */
1345 [ + - ]: 10 : Tcl_DecrRefCount(tcl_cmd);
1346 : :
1347 : : /* Check for errors reported by Tcl. */
3795 peter_e@gmx.net 1348 [ - + ]: 10 : if (tcl_rc != TCL_OK)
3795 peter_e@gmx.net 1349 :UBC 0 : throw_tcl_error(interp, prodesc->user_proname);
1350 : :
3795 peter_e@gmx.net 1351 [ - + ]:CBC 10 : if (SPI_finish() != SPI_OK_FINISH)
3795 peter_e@gmx.net 1352 [ # # ]:UBC 0 : elog(ERROR, "SPI_finish() failed");
3795 peter_e@gmx.net 1353 :CBC 10 : }
1354 : :
1355 : :
1356 : : /**********************************************************************
1357 : : * throw_tcl_error - ereport an error returned from the Tcl interpreter
1358 : : **********************************************************************/
1359 : : static void
5780 tgl@sss.pgh.pa.us 1360 : 45 : throw_tcl_error(Tcl_Interp *interp, const char *proname)
1361 : : {
1362 : : /*
1363 : : * Caution is needed here because Tcl_GetVar could overwrite the
1364 : : * interpreter result (even though it's not really supposed to), and we
1365 : : * can't control the order of evaluation of ereport arguments. Hence, make
1366 : : * real sure we have our own copy of the result string before invoking
1367 : : * Tcl_GetVar.
1368 : : */
1369 : : char *emsg;
1370 : : char *econtext;
1371 : :
2965 1372 : 45 : emsg = pstrdup(utf_u2e(Tcl_GetStringResult(interp)));
1373 : 45 : econtext = utf_u2e(Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY));
5780 1374 [ + - ]: 45 : ereport(ERROR,
1375 : : (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
1376 : : errmsg("%s", emsg),
1377 : : errcontext("%s\nin PL/Tcl function \"%s\"",
1378 : : econtext, proname)));
1379 : : }
1380 : :
1381 : :
1382 : : /**********************************************************************
1383 : : * compile_pltcl_function - compile (or hopefully just look up) function
1384 : : *
1385 : : * tgreloid is the OID of the relation when compiling a trigger, or zero
1386 : : * (InvalidOid) when compiling a plain function.
1387 : : **********************************************************************/
1388 : : static pltcl_proc_desc *
3795 peter_e@gmx.net 1389 : 216 : compile_pltcl_function(Oid fn_oid, Oid tgreloid,
1390 : : bool is_event_trigger, bool pltrusted)
1391 : : {
1392 : : HeapTuple procTup;
1393 : : Form_pg_proc procStruct;
1394 : : pltcl_proc_key proc_key;
1395 : : pltcl_proc_ptr *proc_ptr;
1396 : : bool found;
1397 : : pltcl_proc_desc *prodesc;
1398 : : pltcl_proc_desc *old_prodesc;
2783 tgl@sss.pgh.pa.us 1399 : 216 : volatile MemoryContext proc_cxt = NULL;
1400 : : Tcl_DString proc_internal_def;
1401 : : Tcl_DString proc_internal_body;
1402 : :
1403 : : /* We'll need the pg_proc tuple in any case... */
5173 rhaas@postgresql.org 1404 : 216 : procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fn_oid));
8213 tgl@sss.pgh.pa.us 1405 [ - + ]: 216 : if (!HeapTupleIsValid(procTup))
7569 tgl@sss.pgh.pa.us 1406 [ # # ]:UBC 0 : elog(ERROR, "cache lookup failed for function %u", fn_oid);
8213 tgl@sss.pgh.pa.us 1407 :CBC 216 : procStruct = (Form_pg_proc) GETSTRUCT(procTup);
1408 : :
1409 : : /*
1410 : : * Look up function in pltcl_proc_htab; if it's not there, create an entry
1411 : : * and set the entry's proc_ptr to NULL.
1412 : : */
4945 1413 : 216 : proc_key.proc_id = fn_oid;
4911 1414 : 216 : proc_key.is_trigger = OidIsValid(tgreloid);
4945 1415 [ + - ]: 216 : proc_key.user_id = pltrusted ? GetUserId() : InvalidOid;
1416 : :
1417 : 216 : proc_ptr = hash_search(pltcl_proc_htab, &proc_key,
1418 : : HASH_ENTER,
1419 : : &found);
1420 [ + + ]: 216 : if (!found)
1421 : 56 : proc_ptr->proc_ptr = NULL;
1422 : :
1423 : 216 : prodesc = proc_ptr->proc_ptr;
1424 : :
1425 : : /************************************************************
1426 : : * If it's present, must check whether it's still up to date.
1427 : : * This is needed because CREATE OR REPLACE FUNCTION can modify the
1428 : : * function's pg_proc entry without changing its OID.
1429 : : ************************************************************/
2783 1430 [ + + ]: 216 : if (prodesc != NULL &&
1431 [ + + ]: 157 : prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
1432 [ + - ]: 156 : ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self))
1433 : : {
1434 : : /* It's still up-to-date, so we can use it */
1435 : 156 : ReleaseSysCache(procTup);
1436 : 156 : return prodesc;
1437 : : }
1438 : :
1439 : : /************************************************************
1440 : : * If we haven't found it in the hashtable, we analyze
1441 : : * the functions arguments and returntype and store
1442 : : * the in-/out-functions in the prodesc block and create
1443 : : * a new hashtable entry for it.
1444 : : *
1445 : : * Then we load the procedure into the Tcl interpreter.
1446 : : ************************************************************/
1447 : 60 : Tcl_DStringInit(&proc_internal_def);
1448 : 60 : Tcl_DStringInit(&proc_internal_body);
1449 [ + + ]: 60 : PG_TRY();
1450 : : {
4945 1451 : 60 : bool is_trigger = OidIsValid(tgreloid);
1452 : : char internal_proname[128];
1453 : : HeapTuple typeTup;
1454 : : Form_pg_type typeStruct;
1455 : : char proc_internal_args[33 * FUNC_MAX_ARGS];
1456 : : Datum prosrcdatum;
1457 : : char *proc_source;
1458 : : char buf[48];
1459 : : Tcl_Interp *interp;
1460 : : int i;
1461 : : int tcl_rc;
1462 : : MemoryContext oldcontext;
1463 : :
1464 : : /************************************************************
1465 : : * Build our internal proc name from the function's Oid. Append
1466 : : * "_trigger" when appropriate to ensure the normal and trigger
1467 : : * cases are kept separate. Note name must be all-ASCII.
1468 : : ************************************************************/
2783 1469 [ + + ]: 60 : if (is_event_trigger)
3795 peter_e@gmx.net 1470 : 1 : snprintf(internal_proname, sizeof(internal_proname),
1471 : : "__PLTcl_proc_%u_evttrigger", fn_oid);
1472 [ + + ]: 59 : else if (is_trigger)
4945 tgl@sss.pgh.pa.us 1473 : 8 : snprintf(internal_proname, sizeof(internal_proname),
1474 : : "__PLTcl_proc_%u_trigger", fn_oid);
1475 : : else
2783 1476 : 51 : snprintf(internal_proname, sizeof(internal_proname),
1477 : : "__PLTcl_proc_%u", fn_oid);
1478 : :
1479 : : /************************************************************
1480 : : * Allocate a context that will hold all PG data for the procedure.
1481 : : ************************************************************/
2210 1482 : 60 : proc_cxt = AllocSetContextCreate(TopMemoryContext,
1483 : : "PL/Tcl function",
1484 : : ALLOCSET_SMALL_SIZES);
1485 : :
1486 : : /************************************************************
1487 : : * Allocate and fill a new procedure description block.
1488 : : * struct prodesc and subsidiary data must all live in proc_cxt.
1489 : : ************************************************************/
2783 1490 : 60 : oldcontext = MemoryContextSwitchTo(proc_cxt);
1491 : 60 : prodesc = (pltcl_proc_desc *) palloc0(sizeof(pltcl_proc_desc));
1492 : 60 : prodesc->user_proname = pstrdup(NameStr(procStruct->proname));
2210 1493 : 60 : MemoryContextSetIdentifier(proc_cxt, prodesc->user_proname);
2783 1494 : 60 : prodesc->internal_proname = pstrdup(internal_proname);
1495 : 60 : prodesc->fn_cxt = proc_cxt;
1496 : 60 : prodesc->fn_refcount = 0;
3766 rhaas@postgresql.org 1497 : 60 : prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
6274 tgl@sss.pgh.pa.us 1498 : 60 : prodesc->fn_tid = procTup->t_self;
2783 1499 : 60 : prodesc->nargs = procStruct->pronargs;
1500 : 60 : prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
1501 : 60 : prodesc->arg_is_rowtype = (bool *) palloc0(prodesc->nargs * sizeof(bool));
1502 : 60 : MemoryContextSwitchTo(oldcontext);
1503 : :
1504 : : /* Remember if function is STABLE/IMMUTABLE */
7153 1505 : 60 : prodesc->fn_readonly =
1506 : 60 : (procStruct->provolatile != PROVOLATILE_VOLATILE);
1507 : : /* And whether it is trusted */
4945 1508 : 60 : prodesc->lanpltrusted = pltrusted;
1509 : :
1510 : : /************************************************************
1511 : : * Identify the interpreter to use for the function
1512 : : ************************************************************/
2595 1513 : 117 : prodesc->interp_desc = pltcl_fetch_interp(procStruct->prolang,
1514 : 60 : prodesc->lanpltrusted);
4945 1515 : 57 : interp = prodesc->interp_desc->interp;
1516 : :
1517 : : /************************************************************
1518 : : * Get the required information for input conversion of the
1519 : : * return value.
1520 : : ************************************************************/
2232 peter_e@gmx.net 1521 [ + + + + ]: 57 : if (!is_trigger && !is_event_trigger)
1522 : : {
2362 tgl@sss.pgh.pa.us 1523 : 48 : Oid rettype = procStruct->prorettype;
1524 : :
1525 : 48 : typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(rettype));
8213 1526 [ - + ]: 48 : if (!HeapTupleIsValid(typeTup))
2362 tgl@sss.pgh.pa.us 1527 [ # # ]:UBC 0 : elog(ERROR, "cache lookup failed for type %u", rettype);
8213 tgl@sss.pgh.pa.us 1528 :CBC 48 : typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
1529 : :
1530 : : /* Disallow pseudotype result, except VOID and RECORD */
6222 1531 [ + + ]: 48 : if (typeStruct->typtype == TYPTYPE_PSEUDO)
1532 : : {
2362 1533 [ + + - + ]: 23 : if (rettype == VOIDOID ||
1534 : : rettype == RECORDOID)
1535 : : /* okay */ ;
2362 tgl@sss.pgh.pa.us 1536 [ # # # # ]:UBC 0 : else if (rettype == TRIGGEROID ||
1537 : : rettype == EVENT_TRIGGEROID)
7569 1538 [ # # ]: 0 : ereport(ERROR,
1539 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1540 : : errmsg("trigger functions can only be called as triggers")));
1541 : : else
1542 [ # # ]: 0 : ereport(ERROR,
1543 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1544 : : errmsg("PL/Tcl functions cannot return type %s",
1545 : : format_type_be(rettype))));
1546 : : }
1547 : :
2362 tgl@sss.pgh.pa.us 1548 :CBC 48 : prodesc->result_typid = rettype;
2783 1549 : 48 : fmgr_info_cxt(typeStruct->typinput,
1550 : : &(prodesc->result_in_func),
1551 : : proc_cxt);
7252 1552 : 48 : prodesc->result_typioparam = getTypeIOParam(typeTup);
1553 : :
2716 1554 : 48 : prodesc->fn_retisset = procStruct->proretset;
2362 1555 : 48 : prodesc->fn_retistuple = type_is_rowtype(rettype);
1556 : 48 : prodesc->fn_retisdomain = (typeStruct->typtype == TYPTYPE_DOMAIN);
1557 : 48 : prodesc->domain_info = NULL;
1558 : :
8213 1559 : 48 : ReleaseSysCache(typeTup);
1560 : : }
1561 : :
1562 : : /************************************************************
1563 : : * Get the required information for output conversion
1564 : : * of all procedure arguments, and set up argument naming info.
1565 : : ************************************************************/
3795 peter_e@gmx.net 1566 [ + + + + ]: 57 : if (!is_trigger && !is_event_trigger)
1567 : : {
8213 tgl@sss.pgh.pa.us 1568 : 48 : proc_internal_args[0] = '\0';
1569 [ + + ]: 91 : for (i = 0; i < prodesc->nargs; i++)
1570 : : {
2362 1571 : 43 : Oid argtype = procStruct->proargtypes.values[i];
1572 : :
1573 : 43 : typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(argtype));
8213 1574 [ - + ]: 43 : if (!HeapTupleIsValid(typeTup))
2362 tgl@sss.pgh.pa.us 1575 [ # # ]:UBC 0 : elog(ERROR, "cache lookup failed for type %u", argtype);
8213 tgl@sss.pgh.pa.us 1576 :CBC 43 : typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
1577 : :
1578 : : /* Disallow pseudotype argument, except RECORD */
2362 1579 [ + + - + ]: 43 : if (typeStruct->typtype == TYPTYPE_PSEUDO &&
1580 : : argtype != RECORDOID)
7569 tgl@sss.pgh.pa.us 1581 [ # # ]:UBC 0 : ereport(ERROR,
1582 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1583 : : errmsg("PL/Tcl functions cannot accept type %s",
1584 : : format_type_be(argtype))));
1585 : :
2362 tgl@sss.pgh.pa.us 1586 [ + + ]:CBC 43 : if (type_is_rowtype(argtype))
1587 : : {
7318 1588 : 4 : prodesc->arg_is_rowtype[i] = true;
7853 bruce@momjian.us 1589 : 4 : snprintf(buf, sizeof(buf), "__PLTcl_Tup_%d", i + 1);
1590 : : }
1591 : : else
1592 : : {
7318 tgl@sss.pgh.pa.us 1593 : 39 : prodesc->arg_is_rowtype[i] = false;
2783 1594 : 39 : fmgr_info_cxt(typeStruct->typoutput,
1595 : 39 : &(prodesc->arg_out_func[i]),
1596 : : proc_cxt);
7318 1597 : 39 : snprintf(buf, sizeof(buf), "%d", i + 1);
1598 : : }
1599 : :
8213 1600 [ + + ]: 43 : if (i > 0)
1601 : 14 : strcat(proc_internal_args, " ");
1602 : 43 : strcat(proc_internal_args, buf);
1603 : :
1604 : 43 : ReleaseSysCache(typeTup);
1605 : : }
1606 : : }
3795 peter_e@gmx.net 1607 [ + + ]: 9 : else if (is_trigger)
1608 : : {
1609 : : /* trigger procedure has fixed args */
8213 tgl@sss.pgh.pa.us 1610 : 8 : strcpy(proc_internal_args,
1611 : : "TG_name TG_relid TG_table_name TG_table_schema TG_relatts TG_when TG_level TG_op __PLTcl_Tup_NEW __PLTcl_Tup_OLD args");
1612 : : }
3795 peter_e@gmx.net 1613 [ + - ]: 1 : else if (is_event_trigger)
1614 : : {
1615 : : /* event trigger procedure has fixed args */
1616 : 1 : strcpy(proc_internal_args, "TG_event TG_tag");
1617 : : }
1618 : :
1619 : : /************************************************************
1620 : : * Create the tcl command to define the internal
1621 : : * procedure
1622 : : *
1623 : : * Leave this code as DString - performance is not critical here,
1624 : : * and we don't want to duplicate the knowledge of the Tcl quoting
1625 : : * rules that's embedded in Tcl_DStringAppendElement.
1626 : : ************************************************************/
8213 tgl@sss.pgh.pa.us 1627 : 57 : Tcl_DStringAppendElement(&proc_internal_def, "proc");
1628 : 57 : Tcl_DStringAppendElement(&proc_internal_def, internal_proname);
1629 : 57 : Tcl_DStringAppendElement(&proc_internal_def, proc_internal_args);
1630 : :
1631 : : /************************************************************
1632 : : * prefix procedure body with
1633 : : * upvar #0 <internal_proname> GD
1634 : : * and with appropriate setting of arguments
1635 : : ************************************************************/
1636 : 57 : Tcl_DStringAppend(&proc_internal_body, "upvar #0 ", -1);
1637 : 57 : Tcl_DStringAppend(&proc_internal_body, internal_proname, -1);
1638 : 57 : Tcl_DStringAppend(&proc_internal_body, " GD\n", -1);
3795 peter_e@gmx.net 1639 [ + + ]: 57 : if (is_trigger)
1640 : : {
8213 tgl@sss.pgh.pa.us 1641 : 8 : Tcl_DStringAppend(&proc_internal_body,
1642 : : "array set NEW $__PLTcl_Tup_NEW\n", -1);
1643 : 8 : Tcl_DStringAppend(&proc_internal_body,
1644 : : "array set OLD $__PLTcl_Tup_OLD\n", -1);
1645 : 8 : Tcl_DStringAppend(&proc_internal_body,
1646 : : "set i 0\n"
1647 : : "set v 0\n"
1648 : : "foreach v $args {\n"
1649 : : " incr i\n"
1650 : : " set $i $v\n"
1651 : : "}\n"
1652 : : "unset i v\n\n", -1);
1653 : : }
3795 peter_e@gmx.net 1654 [ + + ]: 49 : else if (is_event_trigger)
1655 : : {
1656 : : /* no argument support for event triggers */
1657 : : }
1658 : : else
1659 : : {
1660 [ + + ]: 91 : for (i = 0; i < prodesc->nargs; i++)
1661 : : {
1662 [ + + ]: 43 : if (prodesc->arg_is_rowtype[i])
1663 : : {
1664 : 4 : snprintf(buf, sizeof(buf),
1665 : : "array set %d $__PLTcl_Tup_%d\n",
1666 : : i + 1, i + 1);
1667 : 4 : Tcl_DStringAppend(&proc_internal_body, buf, -1);
1668 : : }
1669 : : }
1670 : : }
1671 : :
1672 : : /************************************************************
1673 : : * Add user's function definition to proc body
1674 : : ************************************************************/
386 dgustafsson@postgres 1675 : 57 : prosrcdatum = SysCacheGetAttrNotNull(PROCOID, procTup,
1676 : : Anum_pg_proc_prosrc);
5864 tgl@sss.pgh.pa.us 1677 : 57 : proc_source = TextDatumGetCString(prosrcdatum);
8213 1678 : 57 : UTF_BEGIN;
1679 : 57 : Tcl_DStringAppend(&proc_internal_body, UTF_E2U(proc_source), -1);
1680 [ - + ]: 57 : UTF_END;
1681 : 57 : pfree(proc_source);
1682 : 57 : Tcl_DStringAppendElement(&proc_internal_def,
1683 : 57 : Tcl_DStringValue(&proc_internal_body));
1684 : :
1685 : : /************************************************************
1686 : : * Create the procedure in the interpreter
1687 : : ************************************************************/
2965 1688 : 114 : tcl_rc = Tcl_EvalEx(interp,
1689 : 57 : Tcl_DStringValue(&proc_internal_def),
1690 : : Tcl_DStringLength(&proc_internal_def),
1691 : : TCL_EVAL_GLOBAL);
8213 1692 [ - + ]: 57 : if (tcl_rc != TCL_OK)
3178 tgl@sss.pgh.pa.us 1693 [ # # ]:UBC 0 : ereport(ERROR,
1694 : : (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
1695 : : errmsg("could not create internal procedure \"%s\": %s",
1696 : : internal_proname,
1697 : : utf_u2e(Tcl_GetStringResult(interp)))));
1698 : : }
2783 tgl@sss.pgh.pa.us 1699 :CBC 3 : PG_CATCH();
1700 : : {
1701 : : /*
1702 : : * If we failed anywhere above, clean up whatever got allocated. It
1703 : : * should all be in the proc_cxt, except for the DStrings.
1704 : : */
1705 [ + - ]: 3 : if (proc_cxt)
1706 : 3 : MemoryContextDelete(proc_cxt);
1707 : 3 : Tcl_DStringFree(&proc_internal_def);
1708 : 3 : Tcl_DStringFree(&proc_internal_body);
1709 : 3 : PG_RE_THROW();
1710 : : }
1711 [ - + ]: 57 : PG_END_TRY();
1712 : :
1713 : : /*
1714 : : * Install the new proc description block in the hashtable, incrementing
1715 : : * its refcount (the hashtable link counts as a reference). Then, if
1716 : : * there was a previous definition of the function, decrement that one's
1717 : : * refcount, and delete it if no longer referenced. The order of
1718 : : * operations here is important: if something goes wrong during the
1719 : : * MemoryContextDelete, leaking some memory for the old definition is OK,
1720 : : * but we don't want to corrupt the live hashtable entry. (Likewise,
1721 : : * freeing the DStrings is pretty low priority if that happens.)
1722 : : */
1723 : 57 : old_prodesc = proc_ptr->proc_ptr;
1724 : :
1725 : 57 : proc_ptr->proc_ptr = prodesc;
1726 : 57 : prodesc->fn_refcount++;
1727 : :
1728 [ + + ]: 57 : if (old_prodesc != NULL)
1729 : : {
1730 [ - + ]: 1 : Assert(old_prodesc->fn_refcount > 0);
1731 [ + - ]: 1 : if (--old_prodesc->fn_refcount == 0)
1732 : 1 : MemoryContextDelete(old_prodesc->fn_cxt);
1733 : : }
1734 : :
1735 : 57 : Tcl_DStringFree(&proc_internal_def);
1736 : 57 : Tcl_DStringFree(&proc_internal_body);
1737 : :
8213 1738 : 57 : ReleaseSysCache(procTup);
1739 : :
1740 : 57 : return prodesc;
1741 : : }
1742 : :
1743 : :
1744 : : /**********************************************************************
1745 : : * pltcl_elog() - elog() support for PLTcl
1746 : : **********************************************************************/
1747 : : static int
6718 bruce@momjian.us 1748 : 266 : pltcl_elog(ClientData cdata, Tcl_Interp *interp,
1749 : : int objc, Tcl_Obj *const objv[])
1750 : : {
1751 : : volatile int level;
1752 : : MemoryContext oldcontext;
1753 : : int priIndex;
1754 : :
1755 : : static const char *logpriorities[] = {
1756 : : "DEBUG", "LOG", "INFO", "NOTICE",
1757 : : "WARNING", "ERROR", "FATAL", (const char *) NULL
1758 : : };
1759 : :
1760 : : static const int loglevels[] = {
1761 : : DEBUG2, LOG, INFO, NOTICE,
1762 : : WARNING, ERROR, FATAL
1763 : : };
1764 : :
2965 tgl@sss.pgh.pa.us 1765 [ + + ]: 266 : if (objc != 3)
1766 : : {
1767 : 1 : Tcl_WrongNumArgs(interp, 1, objv, "level msg");
9544 bruce@momjian.us 1768 : 1 : return TCL_ERROR;
1769 : : }
1770 : :
2965 tgl@sss.pgh.pa.us 1771 [ + + ]: 265 : if (Tcl_GetIndexFromObj(interp, objv[1], logpriorities, "priority",
1772 : : TCL_EXACT, &priIndex) != TCL_OK)
7738 1773 : 1 : return TCL_ERROR;
1774 : :
2965 1775 : 264 : level = loglevels[priIndex];
1776 : :
5780 1777 [ + + ]: 264 : if (level == ERROR)
1778 : : {
1779 : : /*
1780 : : * We just pass the error back to Tcl. If it's not caught, it'll
1781 : : * eventually get converted to a PG error when we reach the call
1782 : : * handler.
1783 : : */
2965 1784 : 6 : Tcl_SetObjResult(interp, objv[2]);
5780 1785 : 6 : return TCL_ERROR;
1786 : : }
1787 : :
1788 : : /*
1789 : : * For non-error messages, just pass 'em to ereport(). We do not expect
1790 : : * that this will fail, but just on the off chance it does, report the
1791 : : * error back to Tcl. Note we are assuming that ereport() can't have any
1792 : : * internal failures that are so bad as to require a transaction abort.
1793 : : *
1794 : : * This path is also used for FATAL errors, which aren't going to come
1795 : : * back to us at all.
1796 : : */
7197 1797 : 258 : oldcontext = CurrentMemoryContext;
1798 [ + - ]: 258 : PG_TRY();
1799 : : {
1800 : 258 : UTF_BEGIN;
3178 1801 [ + - ]: 258 : ereport(level,
1802 : : (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
1803 : : errmsg("%s", UTF_U2E(Tcl_GetString(objv[2])))));
7197 1804 [ - + ]: 258 : UTF_END;
1805 : : }
7197 tgl@sss.pgh.pa.us 1806 :UBC 0 : PG_CATCH();
1807 : : {
1808 : : ErrorData *edata;
1809 : :
1810 : : /* Must reset elog.c's state */
1811 : 0 : MemoryContextSwitchTo(oldcontext);
7084 1812 : 0 : edata = CopyErrorData();
7197 1813 : 0 : FlushErrorState();
1814 : :
1815 : : /* Pass the error data to Tcl */
2942 1816 : 0 : pltcl_construct_errorCode(interp, edata);
5780 1817 : 0 : UTF_BEGIN;
2965 1818 : 0 : Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
5780 1819 [ # # ]: 0 : UTF_END;
7084 1820 : 0 : FreeErrorData(edata);
1821 : :
9544 bruce@momjian.us 1822 : 0 : return TCL_ERROR;
1823 : : }
7197 tgl@sss.pgh.pa.us 1824 [ - + ]:CBC 258 : PG_END_TRY();
1825 : :
9544 bruce@momjian.us 1826 : 258 : return TCL_OK;
1827 : : }
1828 : :
1829 : :
1830 : : /**********************************************************************
1831 : : * pltcl_construct_errorCode() - construct a Tcl errorCode
1832 : : * list with detailed information from the PostgreSQL server
1833 : : **********************************************************************/
1834 : : static void
2942 tgl@sss.pgh.pa.us 1835 : 18 : pltcl_construct_errorCode(Tcl_Interp *interp, ErrorData *edata)
1836 : : {
1837 : 18 : Tcl_Obj *obj = Tcl_NewObj();
1838 : :
1839 : 18 : Tcl_ListObjAppendElement(interp, obj,
1840 : : Tcl_NewStringObj("POSTGRES", -1));
1841 : 18 : Tcl_ListObjAppendElement(interp, obj,
1842 : : Tcl_NewStringObj(PG_VERSION, -1));
1843 : 18 : Tcl_ListObjAppendElement(interp, obj,
1844 : : Tcl_NewStringObj("SQLSTATE", -1));
1845 : 18 : Tcl_ListObjAppendElement(interp, obj,
2489 1846 : 18 : Tcl_NewStringObj(unpack_sql_state(edata->sqlerrcode), -1));
2942 1847 : 18 : Tcl_ListObjAppendElement(interp, obj,
1848 : : Tcl_NewStringObj("condition", -1));
1849 : 18 : Tcl_ListObjAppendElement(interp, obj,
1850 : : Tcl_NewStringObj(pltcl_get_condition_name(edata->sqlerrcode), -1));
1851 : 18 : Tcl_ListObjAppendElement(interp, obj,
1852 : : Tcl_NewStringObj("message", -1));
1853 : 18 : UTF_BEGIN;
1854 : 18 : Tcl_ListObjAppendElement(interp, obj,
1855 : 18 : Tcl_NewStringObj(UTF_E2U(edata->message), -1));
1856 [ - + ]: 18 : UTF_END;
1857 [ + + ]: 18 : if (edata->detail)
1858 : : {
1859 : 3 : Tcl_ListObjAppendElement(interp, obj,
1860 : : Tcl_NewStringObj("detail", -1));
1861 : 3 : UTF_BEGIN;
1862 : 3 : Tcl_ListObjAppendElement(interp, obj,
2489 1863 : 3 : Tcl_NewStringObj(UTF_E2U(edata->detail), -1));
2942 1864 [ - + ]: 3 : UTF_END;
1865 : : }
1866 [ + + ]: 18 : if (edata->hint)
1867 : : {
1868 : 1 : Tcl_ListObjAppendElement(interp, obj,
1869 : : Tcl_NewStringObj("hint", -1));
1870 : 1 : UTF_BEGIN;
1871 : 1 : Tcl_ListObjAppendElement(interp, obj,
1872 : 1 : Tcl_NewStringObj(UTF_E2U(edata->hint), -1));
1873 [ - + ]: 1 : UTF_END;
1874 : : }
1875 [ + + ]: 18 : if (edata->context)
1876 : : {
1877 : 9 : Tcl_ListObjAppendElement(interp, obj,
1878 : : Tcl_NewStringObj("context", -1));
1879 : 9 : UTF_BEGIN;
1880 : 9 : Tcl_ListObjAppendElement(interp, obj,
2489 1881 : 9 : Tcl_NewStringObj(UTF_E2U(edata->context), -1));
2942 1882 [ - + ]: 9 : UTF_END;
1883 : : }
1884 [ + + ]: 18 : if (edata->schema_name)
1885 : : {
1886 : 3 : Tcl_ListObjAppendElement(interp, obj,
1887 : : Tcl_NewStringObj("schema", -1));
1888 : 3 : UTF_BEGIN;
1889 : 3 : Tcl_ListObjAppendElement(interp, obj,
2489 1890 : 3 : Tcl_NewStringObj(UTF_E2U(edata->schema_name), -1));
2942 1891 [ - + ]: 3 : UTF_END;
1892 : : }
1893 [ + + ]: 18 : if (edata->table_name)
1894 : : {
1895 : 3 : Tcl_ListObjAppendElement(interp, obj,
1896 : : Tcl_NewStringObj("table", -1));
1897 : 3 : UTF_BEGIN;
1898 : 3 : Tcl_ListObjAppendElement(interp, obj,
2489 1899 : 3 : Tcl_NewStringObj(UTF_E2U(edata->table_name), -1));
2942 1900 [ - + ]: 3 : UTF_END;
1901 : : }
1902 [ + + ]: 18 : if (edata->column_name)
1903 : : {
1904 : 1 : Tcl_ListObjAppendElement(interp, obj,
1905 : : Tcl_NewStringObj("column", -1));
1906 : 1 : UTF_BEGIN;
1907 : 1 : Tcl_ListObjAppendElement(interp, obj,
2489 1908 : 1 : Tcl_NewStringObj(UTF_E2U(edata->column_name), -1));
2942 1909 [ - + ]: 1 : UTF_END;
1910 : : }
1911 [ + + ]: 18 : if (edata->datatype_name)
1912 : : {
1913 : 1 : Tcl_ListObjAppendElement(interp, obj,
1914 : : Tcl_NewStringObj("datatype", -1));
1915 : 1 : UTF_BEGIN;
1916 : 1 : Tcl_ListObjAppendElement(interp, obj,
2489 1917 : 1 : Tcl_NewStringObj(UTF_E2U(edata->datatype_name), -1));
2942 1918 [ - + ]: 1 : UTF_END;
1919 : : }
1920 [ + + ]: 18 : if (edata->constraint_name)
1921 : : {
1922 : 3 : Tcl_ListObjAppendElement(interp, obj,
1923 : : Tcl_NewStringObj("constraint", -1));
1924 : 3 : UTF_BEGIN;
1925 : 3 : Tcl_ListObjAppendElement(interp, obj,
2489 1926 : 3 : Tcl_NewStringObj(UTF_E2U(edata->constraint_name), -1));
2942 1927 [ - + ]: 3 : UTF_END;
1928 : : }
1929 : : /* cursorpos is never interesting here; report internal query/pos */
1930 [ + + ]: 18 : if (edata->internalquery)
1931 : : {
1932 : 4 : Tcl_ListObjAppendElement(interp, obj,
1933 : : Tcl_NewStringObj("statement", -1));
1934 : 4 : UTF_BEGIN;
1935 : 4 : Tcl_ListObjAppendElement(interp, obj,
2489 1936 : 4 : Tcl_NewStringObj(UTF_E2U(edata->internalquery), -1));
2942 1937 [ - + ]: 4 : UTF_END;
1938 : : }
1939 [ + + ]: 18 : if (edata->internalpos > 0)
1940 : : {
1941 : 4 : Tcl_ListObjAppendElement(interp, obj,
1942 : : Tcl_NewStringObj("cursor_position", -1));
1943 : 4 : Tcl_ListObjAppendElement(interp, obj,
1944 : : Tcl_NewIntObj(edata->internalpos));
1945 : : }
1946 [ + - ]: 18 : if (edata->filename)
1947 : : {
1948 : 18 : Tcl_ListObjAppendElement(interp, obj,
1949 : : Tcl_NewStringObj("filename", -1));
1950 : 18 : UTF_BEGIN;
1951 : 18 : Tcl_ListObjAppendElement(interp, obj,
2489 1952 : 18 : Tcl_NewStringObj(UTF_E2U(edata->filename), -1));
2942 1953 [ - + ]: 18 : UTF_END;
1954 : : }
1955 [ + - ]: 18 : if (edata->lineno > 0)
1956 : : {
1957 : 18 : Tcl_ListObjAppendElement(interp, obj,
1958 : : Tcl_NewStringObj("lineno", -1));
1959 : 18 : Tcl_ListObjAppendElement(interp, obj,
1960 : : Tcl_NewIntObj(edata->lineno));
1961 : : }
1962 [ + - ]: 18 : if (edata->funcname)
1963 : : {
1964 : 18 : Tcl_ListObjAppendElement(interp, obj,
1965 : : Tcl_NewStringObj("funcname", -1));
1966 : 18 : UTF_BEGIN;
1967 : 18 : Tcl_ListObjAppendElement(interp, obj,
2489 1968 : 18 : Tcl_NewStringObj(UTF_E2U(edata->funcname), -1));
2942 1969 [ - + ]: 18 : UTF_END;
1970 : : }
1971 : :
1972 : 18 : Tcl_SetObjErrorCode(interp, obj);
1973 : 18 : }
1974 : :
1975 : :
1976 : : /**********************************************************************
1977 : : * pltcl_get_condition_name() - find name for SQLSTATE
1978 : : **********************************************************************/
1979 : : static const char *
1980 : 18 : pltcl_get_condition_name(int sqlstate)
1981 : : {
1982 : : int i;
1983 : :
1984 [ + - ]: 2260 : for (i = 0; exception_name_map[i].label != NULL; i++)
1985 : : {
1986 [ + + ]: 2260 : if (exception_name_map[i].sqlerrstate == sqlstate)
1987 : 18 : return exception_name_map[i].label;
1988 : : }
2942 tgl@sss.pgh.pa.us 1989 :UBC 0 : return "unrecognized_sqlstate";
1990 : : }
1991 : :
1992 : :
1993 : : /**********************************************************************
1994 : : * pltcl_quote() - quote literal strings that are to
1995 : : * be used in SPI_execute query strings
1996 : : **********************************************************************/
1997 : : static int
6718 bruce@momjian.us 1998 :CBC 11 : pltcl_quote(ClientData cdata, Tcl_Interp *interp,
1999 : : int objc, Tcl_Obj *const objv[])
2000 : : {
2001 : : char *tmp;
2002 : : const char *cp1;
2003 : : char *cp2;
2004 : : int length;
2005 : :
2006 : : /************************************************************
2007 : : * Check call syntax
2008 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2009 [ + + ]: 11 : if (objc != 2)
2010 : : {
2011 : 1 : Tcl_WrongNumArgs(interp, 1, objv, "string");
9544 bruce@momjian.us 2012 : 1 : return TCL_ERROR;
2013 : : }
2014 : :
2015 : : /************************************************************
2016 : : * Allocate space for the maximum the string can
2017 : : * grow to and initialize pointers
2018 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2019 : 10 : cp1 = Tcl_GetStringFromObj(objv[1], &length);
2020 : 10 : tmp = palloc(length * 2 + 1);
9544 bruce@momjian.us 2021 : 10 : cp2 = tmp;
2022 : :
2023 : : /************************************************************
2024 : : * Walk through string and double every quote and backslash
2025 : : ************************************************************/
2026 [ + + ]: 56 : while (*cp1)
2027 : : {
2028 [ + + ]: 46 : if (*cp1 == '\'')
2029 : 1 : *cp2++ = '\'';
2030 : : else
2031 : : {
2032 [ + + ]: 45 : if (*cp1 == '\\')
2033 : 1 : *cp2++ = '\\';
2034 : : }
2035 : 46 : *cp2++ = *cp1++;
2036 : : }
2037 : :
2038 : : /************************************************************
2039 : : * Terminate the string and set it as result
2040 : : ************************************************************/
2041 : 10 : *cp2 = '\0';
2965 tgl@sss.pgh.pa.us 2042 : 10 : Tcl_SetObjResult(interp, Tcl_NewStringObj(tmp, -1));
9544 bruce@momjian.us 2043 : 10 : pfree(tmp);
2044 : 10 : return TCL_OK;
2045 : : }
2046 : :
2047 : :
2048 : : /**********************************************************************
2049 : : * pltcl_argisnull() - determine if a specific argument is NULL
2050 : : **********************************************************************/
2051 : : static int
6718 2052 : 7 : pltcl_argisnull(ClientData cdata, Tcl_Interp *interp,
2053 : : int objc, Tcl_Obj *const objv[])
2054 : : {
2055 : : int argno;
2716 tgl@sss.pgh.pa.us 2056 : 7 : FunctionCallInfo fcinfo = pltcl_current_call_state->fcinfo;
2057 : :
2058 : : /************************************************************
2059 : : * Check call syntax
2060 : : ************************************************************/
2965 2061 [ + + ]: 7 : if (objc != 2)
2062 : : {
2063 : 1 : Tcl_WrongNumArgs(interp, 1, objv, "argno");
8670 JanWieck@Yahoo.com 2064 : 1 : return TCL_ERROR;
2065 : : }
2066 : :
2067 : : /************************************************************
2068 : : * Check that we're called as a normal function
2069 : : ************************************************************/
2070 [ + + ]: 6 : if (fcinfo == NULL)
2071 : : {
2965 tgl@sss.pgh.pa.us 2072 : 1 : Tcl_SetObjResult(interp,
2073 : : Tcl_NewStringObj("argisnull cannot be used in triggers", -1));
8670 JanWieck@Yahoo.com 2074 : 1 : return TCL_ERROR;
2075 : : }
2076 : :
2077 : : /************************************************************
2078 : : * Get the argument number
2079 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2080 [ + + ]: 5 : if (Tcl_GetIntFromObj(interp, objv[1], &argno) != TCL_OK)
8458 2081 : 1 : return TCL_ERROR;
2082 : :
2083 : : /************************************************************
2084 : : * Check that the argno is valid
2085 : : ************************************************************/
8670 JanWieck@Yahoo.com 2086 : 4 : argno--;
2087 [ + - + + ]: 4 : if (argno < 0 || argno >= fcinfo->nargs)
2088 : : {
2965 tgl@sss.pgh.pa.us 2089 : 1 : Tcl_SetObjResult(interp,
2090 : : Tcl_NewStringObj("argno out of range", -1));
8670 JanWieck@Yahoo.com 2091 : 1 : return TCL_ERROR;
2092 : : }
2093 : :
2094 : : /************************************************************
2095 : : * Get the requested NULL state
2096 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2097 : 3 : Tcl_SetObjResult(interp, Tcl_NewBooleanObj(PG_ARGISNULL(argno)));
8670 JanWieck@Yahoo.com 2098 : 3 : return TCL_OK;
2099 : : }
2100 : :
2101 : :
2102 : : /**********************************************************************
2103 : : * pltcl_returnnull() - Cause a NULL return from the current function
2104 : : **********************************************************************/
2105 : : static int
6718 bruce@momjian.us 2106 : 3 : pltcl_returnnull(ClientData cdata, Tcl_Interp *interp,
2107 : : int objc, Tcl_Obj *const objv[])
2108 : : {
2716 tgl@sss.pgh.pa.us 2109 : 3 : FunctionCallInfo fcinfo = pltcl_current_call_state->fcinfo;
2110 : :
2111 : : /************************************************************
2112 : : * Check call syntax
2113 : : ************************************************************/
2965 2114 [ + + ]: 3 : if (objc != 1)
2115 : : {
2116 : 1 : Tcl_WrongNumArgs(interp, 1, objv, "");
8670 JanWieck@Yahoo.com 2117 : 1 : return TCL_ERROR;
2118 : : }
2119 : :
2120 : : /************************************************************
2121 : : * Check that we're called as a normal function
2122 : : ************************************************************/
8458 tgl@sss.pgh.pa.us 2123 [ + + ]: 2 : if (fcinfo == NULL)
2124 : : {
2965 2125 : 1 : Tcl_SetObjResult(interp,
2126 : : Tcl_NewStringObj("return_null cannot be used in triggers", -1));
8458 2127 : 1 : return TCL_ERROR;
2128 : : }
2129 : :
2130 : : /************************************************************
2131 : : * Set the NULL return flag and cause Tcl to return from the
2132 : : * procedure.
2133 : : ************************************************************/
8670 JanWieck@Yahoo.com 2134 : 1 : fcinfo->isnull = true;
2135 : :
2136 : 1 : return TCL_RETURN;
2137 : : }
2138 : :
2139 : :
2140 : : /**********************************************************************
2141 : : * pltcl_returnnext() - Add a row to the result tuplestore in a SRF.
2142 : : **********************************************************************/
2143 : : static int
2716 tgl@sss.pgh.pa.us 2144 : 18 : pltcl_returnnext(ClientData cdata, Tcl_Interp *interp,
2145 : : int objc, Tcl_Obj *const objv[])
2146 : : {
2147 : 18 : pltcl_call_state *call_state = pltcl_current_call_state;
2148 : 18 : FunctionCallInfo fcinfo = call_state->fcinfo;
2149 : 18 : pltcl_proc_desc *prodesc = call_state->prodesc;
2652 2150 : 18 : MemoryContext oldcontext = CurrentMemoryContext;
2151 : 18 : ResourceOwner oldowner = CurrentResourceOwner;
2152 : 18 : volatile int result = TCL_OK;
2153 : :
2154 : : /*
2155 : : * Check that we're called as a set-returning function
2156 : : */
2716 2157 [ - + ]: 18 : if (fcinfo == NULL)
2158 : : {
2716 tgl@sss.pgh.pa.us 2159 :UBC 0 : Tcl_SetObjResult(interp,
2160 : : Tcl_NewStringObj("return_next cannot be used in triggers", -1));
2161 : 0 : return TCL_ERROR;
2162 : : }
2163 : :
2716 tgl@sss.pgh.pa.us 2164 [ + + ]:CBC 18 : if (!prodesc->fn_retisset)
2165 : : {
2166 : 1 : Tcl_SetObjResult(interp,
2167 : : Tcl_NewStringObj("return_next cannot be used in non-set-returning functions", -1));
2168 : 1 : return TCL_ERROR;
2169 : : }
2170 : :
2171 : : /*
2172 : : * Check call syntax
2173 : : */
2174 [ - + ]: 17 : if (objc != 2)
2175 : : {
2716 tgl@sss.pgh.pa.us 2176 :UBC 0 : Tcl_WrongNumArgs(interp, 1, objv, "result");
2177 : 0 : return TCL_ERROR;
2178 : : }
2179 : :
2180 : : /*
2181 : : * The rest might throw elog(ERROR), so must run in a subtransaction.
2182 : : *
2183 : : * A small advantage of using a subtransaction is that it provides a
2184 : : * short-lived memory context for free, so we needn't worry about leaking
2185 : : * memory here. To use that context, call BeginInternalSubTransaction
2186 : : * directly instead of going through pltcl_subtrans_begin.
2187 : : */
2652 tgl@sss.pgh.pa.us 2188 :CBC 17 : BeginInternalSubTransaction(NULL);
2189 [ + + ]: 17 : PG_TRY();
2190 : : {
2191 : : /* Set up tuple store if first output row */
2192 [ + + ]: 17 : if (call_state->tuple_store == NULL)
2193 : 5 : pltcl_init_tuple_store(call_state);
2194 : :
2195 [ + + ]: 17 : if (prodesc->fn_retistuple)
2196 : : {
2197 : : Tcl_Obj **rowObjv;
2198 : : int rowObjc;
2199 : :
2200 : : /* result should be a list, so break it down */
2201 [ - + ]: 7 : if (Tcl_ListObjGetElements(interp, objv[1], &rowObjc, &rowObjv) == TCL_ERROR)
2652 tgl@sss.pgh.pa.us 2202 :UBC 0 : result = TCL_ERROR;
2203 : : else
2204 : : {
2205 : : HeapTuple tuple;
2206 : :
2652 tgl@sss.pgh.pa.us 2207 :CBC 7 : tuple = pltcl_build_tuple_result(interp, rowObjv, rowObjc,
2208 : : call_state);
2209 : 5 : tuplestore_puttuple(call_state->tuple_store, tuple);
2210 : : }
2211 : : }
2212 : : else
2213 : : {
2214 : : Datum retval;
2215 : 10 : bool isNull = false;
2216 : :
2217 : : /* for paranoia's sake, check that tupdesc has exactly one column */
2218 [ - + ]: 10 : if (call_state->ret_tupdesc->natts != 1)
2652 tgl@sss.pgh.pa.us 2219 [ # # ]:UBC 0 : elog(ERROR, "wrong result type supplied in return_next");
2220 : :
2652 tgl@sss.pgh.pa.us 2221 :CBC 10 : retval = InputFunctionCall(&prodesc->result_in_func,
2489 2222 : 10 : utf_u2e((char *) Tcl_GetString(objv[1])),
2223 : : prodesc->result_typioparam,
2224 : : -1);
2652 2225 : 10 : tuplestore_putvalues(call_state->tuple_store, call_state->ret_tupdesc,
2226 : : &retval, &isNull);
2227 : : }
2228 : :
2229 : 15 : pltcl_subtrans_commit(oldcontext, oldowner);
2230 : : }
2231 : 2 : PG_CATCH();
2232 : : {
2233 : 2 : pltcl_subtrans_abort(interp, oldcontext, oldowner);
2234 : 2 : return TCL_ERROR;
2235 : : }
2236 [ - + ]: 15 : PG_END_TRY();
2237 : :
2716 2238 : 15 : return result;
2239 : : }
2240 : :
2241 : :
2242 : : /*----------
2243 : : * Support for running SPI operations inside subtransactions
2244 : : *
2245 : : * Intended usage pattern is:
2246 : : *
2247 : : * MemoryContext oldcontext = CurrentMemoryContext;
2248 : : * ResourceOwner oldowner = CurrentResourceOwner;
2249 : : *
2250 : : * ...
2251 : : * pltcl_subtrans_begin(oldcontext, oldowner);
2252 : : * PG_TRY();
2253 : : * {
2254 : : * do something risky;
2255 : : * pltcl_subtrans_commit(oldcontext, oldowner);
2256 : : * }
2257 : : * PG_CATCH();
2258 : : * {
2259 : : * pltcl_subtrans_abort(interp, oldcontext, oldowner);
2260 : : * return TCL_ERROR;
2261 : : * }
2262 : : * PG_END_TRY();
2263 : : * return TCL_OK;
2264 : : *----------
2265 : : */
2266 : : static void
7084 2267 : 122 : pltcl_subtrans_begin(MemoryContext oldcontext, ResourceOwner oldowner)
2268 : : {
2269 : 122 : BeginInternalSubTransaction(NULL);
2270 : :
2271 : : /* Want to run inside function's memory context */
2272 : 122 : MemoryContextSwitchTo(oldcontext);
2273 : 122 : }
2274 : :
2275 : : static void
2276 : 127 : pltcl_subtrans_commit(MemoryContext oldcontext, ResourceOwner oldowner)
2277 : : {
2278 : : /* Commit the inner transaction, return to outer xact context */
2279 : 127 : ReleaseCurrentSubTransaction();
2280 : 127 : MemoryContextSwitchTo(oldcontext);
2281 : 127 : CurrentResourceOwner = oldowner;
2282 : 127 : }
2283 : :
2284 : : static void
6718 bruce@momjian.us 2285 : 12 : pltcl_subtrans_abort(Tcl_Interp *interp,
2286 : : MemoryContext oldcontext, ResourceOwner oldowner)
2287 : : {
2288 : : ErrorData *edata;
2289 : :
2290 : : /* Save error info */
7084 tgl@sss.pgh.pa.us 2291 : 12 : MemoryContextSwitchTo(oldcontext);
2292 : 12 : edata = CopyErrorData();
2293 : 12 : FlushErrorState();
2294 : :
2295 : : /* Abort the inner transaction */
2296 : 12 : RollbackAndReleaseCurrentSubTransaction();
2297 : 12 : MemoryContextSwitchTo(oldcontext);
2298 : 12 : CurrentResourceOwner = oldowner;
2299 : :
2300 : : /* Pass the error data to Tcl */
2942 2301 : 12 : pltcl_construct_errorCode(interp, edata);
5780 2302 : 12 : UTF_BEGIN;
2942 2303 : 12 : Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
5780 2304 [ - + ]: 12 : UTF_END;
7084 2305 : 12 : FreeErrorData(edata);
2306 : 12 : }
2307 : :
2308 : :
2309 : : /**********************************************************************
2310 : : * pltcl_SPI_execute() - The builtin SPI_execute command
2311 : : * for the Tcl interpreter
2312 : : **********************************************************************/
2313 : : static int
6718 bruce@momjian.us 2314 : 63 : pltcl_SPI_execute(ClientData cdata, Tcl_Interp *interp,
2315 : : int objc, Tcl_Obj *const objv[])
2316 : : {
2317 : : int my_rc;
2318 : : int spi_rc;
2319 : : int query_idx;
2320 : : int i;
2321 : : int optIndex;
9544 2322 : 63 : int count = 0;
2965 tgl@sss.pgh.pa.us 2323 : 63 : const char *volatile arrayname = NULL;
2324 : 63 : Tcl_Obj *volatile loop_body = NULL;
7084 2325 : 63 : MemoryContext oldcontext = CurrentMemoryContext;
2326 : 63 : ResourceOwner oldowner = CurrentResourceOwner;
2327 : :
2328 : : enum options
2329 : : {
2330 : : OPT_ARRAY, OPT_COUNT
2331 : : };
2332 : :
2333 : : static const char *options[] = {
2334 : : "-array", "-count", (const char *) NULL
2335 : : };
2336 : :
2337 : : /************************************************************
2338 : : * Check the call syntax and get the options
2339 : : ************************************************************/
2965 2340 [ + + ]: 63 : if (objc < 2)
2341 : : {
2342 : 1 : Tcl_WrongNumArgs(interp, 1, objv,
2343 : : "?-count n? ?-array name? query ?loop body?");
9544 bruce@momjian.us 2344 : 1 : return TCL_ERROR;
2345 : : }
2346 : :
2347 : 62 : i = 1;
2965 tgl@sss.pgh.pa.us 2348 [ + - ]: 132 : while (i < objc)
2349 : : {
2717 2350 [ + + ]: 70 : if (Tcl_GetIndexFromObj(NULL, objv[i], options, NULL,
2351 : : TCL_EXACT, &optIndex) != TCL_OK)
2965 2352 : 59 : break;
2353 : :
2354 [ + + ]: 11 : if (++i >= objc)
2355 : : {
2356 : 2 : Tcl_SetObjResult(interp,
2357 : : Tcl_NewStringObj("missing argument to -count or -array", -1));
2358 : 2 : return TCL_ERROR;
2359 : : }
2360 : :
2361 [ - + + ]: 9 : switch ((enum options) optIndex)
2362 : : {
2363 : 8 : case OPT_ARRAY:
2364 : 8 : arrayname = Tcl_GetString(objv[i++]);
2365 : 8 : break;
2366 : :
2367 : 1 : case OPT_COUNT:
2368 [ + - ]: 1 : if (Tcl_GetIntFromObj(interp, objv[i++], &count) != TCL_OK)
2369 : 1 : return TCL_ERROR;
2965 tgl@sss.pgh.pa.us 2370 :UBC 0 : break;
2371 : : }
2372 : : }
2373 : :
9544 bruce@momjian.us 2374 :CBC 59 : query_idx = i;
2965 tgl@sss.pgh.pa.us 2375 [ + - + + ]: 59 : if (query_idx >= objc || query_idx + 2 < objc)
2376 : : {
2377 : 1 : Tcl_WrongNumArgs(interp, query_idx - 1, objv, "query ?loop body?");
9544 bruce@momjian.us 2378 : 1 : return TCL_ERROR;
2379 : : }
2380 : :
2965 tgl@sss.pgh.pa.us 2381 [ + + ]: 58 : if (query_idx + 1 < objc)
2382 : 8 : loop_body = objv[query_idx + 1];
2383 : :
2384 : : /************************************************************
2385 : : * Execute the query inside a sub-transaction, so we can cope with
2386 : : * errors sanely
2387 : : ************************************************************/
2388 : :
7084 2389 : 58 : pltcl_subtrans_begin(oldcontext, oldowner);
2390 : :
7197 2391 [ + + ]: 58 : PG_TRY();
2392 : : {
2393 : 58 : UTF_BEGIN;
2965 2394 : 58 : spi_rc = SPI_execute(UTF_U2E(Tcl_GetString(objv[query_idx])),
2489 2395 : 58 : pltcl_current_call_state->prodesc->fn_readonly, count);
7197 2396 [ - + ]: 50 : UTF_END;
2397 : :
7084 2398 : 50 : my_rc = pltcl_process_SPI_result(interp,
2399 : : arrayname,
2400 : : loop_body,
2401 : : spi_rc,
2402 : : SPI_tuptable,
2403 : : SPI_processed);
2404 : :
2405 : 50 : pltcl_subtrans_commit(oldcontext, oldowner);
2406 : : }
7197 2407 : 8 : PG_CATCH();
2408 : : {
7084 2409 : 8 : pltcl_subtrans_abort(interp, oldcontext, oldowner);
9544 bruce@momjian.us 2410 : 8 : return TCL_ERROR;
2411 : : }
7197 tgl@sss.pgh.pa.us 2412 [ - + ]: 50 : PG_END_TRY();
2413 : :
7084 2414 : 50 : return my_rc;
2415 : : }
2416 : :
2417 : : /*
2418 : : * Process the result from SPI_execute or SPI_execute_plan
2419 : : *
2420 : : * Shared code between pltcl_SPI_execute and pltcl_SPI_execute_plan
2421 : : */
2422 : : static int
6718 bruce@momjian.us 2423 : 99 : pltcl_process_SPI_result(Tcl_Interp *interp,
2424 : : const char *arrayname,
2425 : : Tcl_Obj *loop_body,
2426 : : int spi_rc,
2427 : : SPITupleTable *tuptable,
2428 : : uint64 ntuples)
2429 : : {
7084 tgl@sss.pgh.pa.us 2430 : 99 : int my_rc = TCL_OK;
2431 : : int loop_rc;
2432 : : HeapTuple *tuples;
2433 : : TupleDesc tupdesc;
2434 : :
9544 bruce@momjian.us 2435 [ + - + + ]: 99 : switch (spi_rc)
2436 : : {
2437 : 37 : case SPI_OK_SELINTO:
2438 : : case SPI_OK_INSERT:
2439 : : case SPI_OK_DELETE:
2440 : : case SPI_OK_UPDATE:
2441 : : case SPI_OK_MERGE:
2955 tgl@sss.pgh.pa.us 2442 : 37 : Tcl_SetObjResult(interp, Tcl_NewWideIntObj(ntuples));
9544 bruce@momjian.us 2443 : 37 : break;
2444 : :
6440 tgl@sss.pgh.pa.us 2445 :UBC 0 : case SPI_OK_UTILITY:
2446 : : case SPI_OK_REWRITTEN:
2447 [ # # ]: 0 : if (tuptable == NULL)
2448 : : {
2965 2449 : 0 : Tcl_SetObjResult(interp, Tcl_NewIntObj(0));
6440 2450 : 0 : break;
2451 : : }
2452 : : /* fall through for utility returning tuples */
2453 : : /* FALLTHROUGH */
2454 : :
2455 : : case SPI_OK_SELECT:
2456 : : case SPI_OK_INSERT_RETURNING:
2457 : : case SPI_OK_DELETE_RETURNING:
2458 : : case SPI_OK_UPDATE_RETURNING:
2459 : : case SPI_OK_MERGE_RETURNING:
2460 : :
2461 : : /*
2462 : : * Process the tuples we got
2463 : : */
7084 tgl@sss.pgh.pa.us 2464 :CBC 61 : tuples = tuptable->vals;
2465 : 61 : tupdesc = tuptable->tupdesc;
2466 : :
2467 [ + + ]: 61 : if (loop_body == NULL)
2468 : : {
2469 : : /*
2470 : : * If there is no loop body given, just set the variables from
2471 : : * the first tuple (if any)
2472 : : */
2473 [ + + ]: 49 : if (ntuples > 0)
2474 : 28 : pltcl_set_tuple_values(interp, arrayname, 0,
2475 : : tuples[0], tupdesc);
2476 : : }
2477 : : else
2478 : : {
2479 : : /*
2480 : : * There is a loop body - process all tuples and evaluate the
2481 : : * body on each
2482 : : */
2483 : : uint64 i;
2484 : :
2485 [ + + ]: 26 : for (i = 0; i < ntuples; i++)
2486 : : {
2487 : 22 : pltcl_set_tuple_values(interp, arrayname, i,
2488 : 22 : tuples[i], tupdesc);
2489 : :
2965 2490 : 22 : loop_rc = Tcl_EvalObjEx(interp, loop_body, 0);
2491 : :
7084 2492 [ + + ]: 22 : if (loop_rc == TCL_OK)
2493 : 12 : continue;
2494 [ + + ]: 10 : if (loop_rc == TCL_CONTINUE)
2495 : 2 : continue;
2496 [ + + ]: 8 : if (loop_rc == TCL_RETURN)
2497 : : {
2498 : 2 : my_rc = TCL_RETURN;
2499 : 2 : break;
2500 : : }
2501 [ + + ]: 6 : if (loop_rc == TCL_BREAK)
2502 : 2 : break;
2503 : 4 : my_rc = TCL_ERROR;
7197 2504 : 4 : break;
2505 : : }
2506 : : }
2507 : :
7084 2508 [ + + ]: 61 : if (my_rc == TCL_OK)
2509 : : {
2955 2510 : 55 : Tcl_SetObjResult(interp, Tcl_NewWideIntObj(ntuples));
2511 : : }
7084 2512 : 61 : break;
2513 : :
2514 : 1 : default:
2515 : 1 : Tcl_AppendResult(interp, "pltcl: SPI_execute failed: ",
2516 : : SPI_result_code_string(spi_rc), NULL);
2517 : 1 : my_rc = TCL_ERROR;
2518 : 1 : break;
2519 : : }
2520 : :
2521 : 99 : SPI_freetuptable(tuptable);
2522 : :
7197 2523 : 99 : return my_rc;
2524 : : }
2525 : :
2526 : :
2527 : : /**********************************************************************
2528 : : * pltcl_SPI_prepare() - Builtin support for prepared plans
2529 : : * The Tcl command SPI_prepare
2530 : : * always saves the plan using
2531 : : * SPI_keepplan and returns a key for
2532 : : * access. There is no chance to prepare
2533 : : * and not save the plan currently.
2534 : : **********************************************************************/
2535 : : static int
6718 bruce@momjian.us 2536 : 17 : pltcl_SPI_prepare(ClientData cdata, Tcl_Interp *interp,
2537 : : int objc, Tcl_Obj *const objv[])
2538 : : {
3192 alvherre@alvh.no-ip. 2539 : 17 : volatile MemoryContext plan_cxt = NULL;
2540 : : int nargs;
2541 : : Tcl_Obj **argsObj;
2542 : : pltcl_query_desc *qdesc;
2543 : : int i;
2544 : : Tcl_HashEntry *hashent;
2545 : : int hashnew;
2546 : : Tcl_HashTable *query_hash;
7084 tgl@sss.pgh.pa.us 2547 : 17 : MemoryContext oldcontext = CurrentMemoryContext;
2548 : 17 : ResourceOwner oldowner = CurrentResourceOwner;
2549 : :
2550 : : /************************************************************
2551 : : * Check the call syntax
2552 : : ************************************************************/
2965 2553 [ + + ]: 17 : if (objc != 3)
2554 : : {
2555 : 1 : Tcl_WrongNumArgs(interp, 1, objv, "query argtypes");
9544 bruce@momjian.us 2556 : 1 : return TCL_ERROR;
2557 : : }
2558 : :
2559 : : /************************************************************
2560 : : * Split the argument type list
2561 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2562 [ + + ]: 16 : if (Tcl_ListObjGetElements(interp, objv[2], &nargs, &argsObj) != TCL_OK)
9544 bruce@momjian.us 2563 : 1 : return TCL_ERROR;
2564 : :
2565 : : /************************************************************
2566 : : * Allocate the new querydesc structure
2567 : : *
2568 : : * struct qdesc and subsidiary data all live in plan_cxt. Note that if the
2569 : : * function is recompiled for whatever reason, permanent memory leaks
2570 : : * occur. FIXME someday.
2571 : : ************************************************************/
3192 alvherre@alvh.no-ip. 2572 : 15 : plan_cxt = AllocSetContextCreate(TopMemoryContext,
2573 : : "PL/Tcl spi_prepare query",
2574 : : ALLOCSET_SMALL_SIZES);
2575 : 15 : MemoryContextSwitchTo(plan_cxt);
2576 : 15 : qdesc = (pltcl_query_desc *) palloc0(sizeof(pltcl_query_desc));
5218 tgl@sss.pgh.pa.us 2577 : 15 : snprintf(qdesc->qname, sizeof(qdesc->qname), "%p", qdesc);
9544 bruce@momjian.us 2578 : 15 : qdesc->nargs = nargs;
3192 alvherre@alvh.no-ip. 2579 : 15 : qdesc->argtypes = (Oid *) palloc(nargs * sizeof(Oid));
2580 : 15 : qdesc->arginfuncs = (FmgrInfo *) palloc(nargs * sizeof(FmgrInfo));
2581 : 15 : qdesc->argtypioparams = (Oid *) palloc(nargs * sizeof(Oid));
2582 : 15 : MemoryContextSwitchTo(oldcontext);
2583 : :
2584 : : /************************************************************
2585 : : * Execute the prepare inside a sub-transaction, so we can cope with
2586 : : * errors sanely
2587 : : ************************************************************/
2588 : :
7084 tgl@sss.pgh.pa.us 2589 : 15 : pltcl_subtrans_begin(oldcontext, oldowner);
2590 : :
7197 2591 [ + + ]: 15 : PG_TRY();
2592 : : {
2593 : : /************************************************************
2594 : : * Resolve argument type names and then look them up by oid
2595 : : * in the system cache, and remember the required information
2596 : : * for input conversion.
2597 : : ************************************************************/
7168 bruce@momjian.us 2598 [ + + ]: 34 : for (i = 0; i < nargs; i++)
2599 : : {
2600 : : Oid typId,
2601 : : typInput,
2602 : : typIOParam;
2603 : : int32 typmod;
2604 : :
474 tgl@sss.pgh.pa.us 2605 : 20 : (void) parseTypeString(Tcl_GetString(argsObj[i]),
2606 : : &typId, &typmod, NULL);
2607 : :
6262 andrew@dunslane.net 2608 : 19 : getTypeInputInfo(typId, &typInput, &typIOParam);
2609 : :
2610 : 19 : qdesc->argtypes[i] = typId;
3192 alvherre@alvh.no-ip. 2611 : 19 : fmgr_info_cxt(typInput, &(qdesc->arginfuncs[i]), plan_cxt);
6262 andrew@dunslane.net 2612 : 19 : qdesc->argtypioparams[i] = typIOParam;
2613 : : }
2614 : :
2615 : : /************************************************************
2616 : : * Prepare the plan and check for errors
2617 : : ************************************************************/
7168 bruce@momjian.us 2618 : 14 : UTF_BEGIN;
2965 tgl@sss.pgh.pa.us 2619 : 14 : qdesc->plan = SPI_prepare(UTF_U2E(Tcl_GetString(objv[1])),
2620 : : nargs, qdesc->argtypes);
7168 bruce@momjian.us 2621 [ - + ]: 13 : UTF_END;
2622 : :
4594 tgl@sss.pgh.pa.us 2623 [ - + ]: 13 : if (qdesc->plan == NULL)
7168 bruce@momjian.us 2624 [ # # ]:UBC 0 : elog(ERROR, "SPI_prepare() failed");
2625 : :
2626 : : /************************************************************
2627 : : * Save the plan into permanent memory (right now it's in the
2628 : : * SPI procCxt, which will go away at function end).
2629 : : ************************************************************/
4594 tgl@sss.pgh.pa.us 2630 [ - + ]:CBC 13 : if (SPI_keepplan(qdesc->plan))
4594 tgl@sss.pgh.pa.us 2631 [ # # ]:UBC 0 : elog(ERROR, "SPI_keepplan() failed");
2632 : :
7084 tgl@sss.pgh.pa.us 2633 :CBC 13 : pltcl_subtrans_commit(oldcontext, oldowner);
2634 : : }
7197 2635 : 2 : PG_CATCH();
2636 : : {
7084 2637 : 2 : pltcl_subtrans_abort(interp, oldcontext, oldowner);
2638 : :
3192 alvherre@alvh.no-ip. 2639 : 2 : MemoryContextDelete(plan_cxt);
2640 : :
7197 tgl@sss.pgh.pa.us 2641 : 2 : return TCL_ERROR;
2642 : : }
2643 [ - + ]: 13 : PG_END_TRY();
2644 : :
2645 : : /************************************************************
2646 : : * Insert a hashtable entry for the plan and return
2647 : : * the key to the caller
2648 : : ************************************************************/
2716 2649 : 13 : query_hash = &pltcl_current_call_state->prodesc->interp_desc->query_hash;
2650 : :
8670 JanWieck@Yahoo.com 2651 : 13 : hashent = Tcl_CreateHashEntry(query_hash, qdesc->qname, &hashnew);
9544 bruce@momjian.us 2652 : 13 : Tcl_SetHashValue(hashent, (ClientData) qdesc);
2653 : :
2654 : : /* qname is ASCII, so no need for encoding conversion */
2965 tgl@sss.pgh.pa.us 2655 : 13 : Tcl_SetObjResult(interp, Tcl_NewStringObj(qdesc->qname, -1));
9544 bruce@momjian.us 2656 : 13 : return TCL_OK;
2657 : : }
2658 : :
2659 : :
2660 : : /**********************************************************************
2661 : : * pltcl_SPI_execute_plan() - Execute a prepared plan
2662 : : **********************************************************************/
2663 : : static int
6718 2664 : 55 : pltcl_SPI_execute_plan(ClientData cdata, Tcl_Interp *interp,
2665 : : int objc, Tcl_Obj *const objv[])
2666 : : {
2667 : : int my_rc;
2668 : : int spi_rc;
2669 : : int i;
2670 : : int j;
2671 : : int optIndex;
2672 : : Tcl_HashEntry *hashent;
2673 : : pltcl_query_desc *qdesc;
3366 tgl@sss.pgh.pa.us 2674 : 55 : const char *nulls = NULL;
2965 2675 : 55 : const char *arrayname = NULL;
2676 : 55 : Tcl_Obj *loop_body = NULL;
9544 bruce@momjian.us 2677 : 55 : int count = 0;
2678 : : int callObjc;
2965 tgl@sss.pgh.pa.us 2679 : 55 : Tcl_Obj **callObjv = NULL;
2680 : : Datum *argvalues;
7084 2681 : 55 : MemoryContext oldcontext = CurrentMemoryContext;
2682 : 55 : ResourceOwner oldowner = CurrentResourceOwner;
2683 : : Tcl_HashTable *query_hash;
2684 : :
2685 : : enum options
2686 : : {
2687 : : OPT_ARRAY, OPT_COUNT, OPT_NULLS
2688 : : };
2689 : :
2690 : : static const char *options[] = {
2691 : : "-array", "-count", "-nulls", (const char *) NULL
2692 : : };
2693 : :
2694 : : /************************************************************
2695 : : * Get the options and check syntax
2696 : : ************************************************************/
9544 bruce@momjian.us 2697 : 55 : i = 1;
2965 tgl@sss.pgh.pa.us 2698 [ + + ]: 154 : while (i < objc)
2699 : : {
2717 2700 [ + + ]: 98 : if (Tcl_GetIndexFromObj(NULL, objv[i], options, NULL,
2701 : : TCL_EXACT, &optIndex) != TCL_OK)
2965 2702 : 50 : break;
2703 : :
2704 [ + + ]: 48 : if (++i >= objc)
2705 : : {
2706 : 3 : Tcl_SetObjResult(interp,
2707 : : Tcl_NewStringObj("missing argument to -array, -count or -nulls", -1));
2708 : 3 : return TCL_ERROR;
2709 : : }
2710 : :
2711 [ + + - - ]: 45 : switch ((enum options) optIndex)
2712 : : {
2713 : 4 : case OPT_ARRAY:
2714 : 4 : arrayname = Tcl_GetString(objv[i++]);
2715 : 4 : break;
2716 : :
2717 : 41 : case OPT_COUNT:
2718 [ + + ]: 41 : if (Tcl_GetIntFromObj(interp, objv[i++], &count) != TCL_OK)
2719 : 1 : return TCL_ERROR;
2720 : 40 : break;
2721 : :
2965 tgl@sss.pgh.pa.us 2722 :UBC 0 : case OPT_NULLS:
2723 : 0 : nulls = Tcl_GetString(objv[i++]);
2724 : 0 : break;
2725 : : }
2726 : : }
2727 : :
2728 : : /************************************************************
2729 : : * Get the prepared plan descriptor by its key
2730 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2731 [ + + ]:CBC 51 : if (i >= objc)
2732 : : {
2733 : 1 : Tcl_SetObjResult(interp,
2734 : : Tcl_NewStringObj("missing argument to -count or -array", -1));
9559 scrappy@hub.org 2735 : 1 : return TCL_ERROR;
2736 : : }
2737 : :
2716 tgl@sss.pgh.pa.us 2738 : 50 : query_hash = &pltcl_current_call_state->prodesc->interp_desc->query_hash;
2739 : :
2965 2740 : 50 : hashent = Tcl_FindHashEntry(query_hash, Tcl_GetString(objv[i]));
9544 bruce@momjian.us 2741 [ + + ]: 50 : if (hashent == NULL)
2742 : : {
2965 tgl@sss.pgh.pa.us 2743 : 1 : Tcl_AppendResult(interp, "invalid queryid '", Tcl_GetString(objv[i]), "'", NULL);
9544 bruce@momjian.us 2744 : 1 : return TCL_ERROR;
2745 : : }
2746 : 49 : qdesc = (pltcl_query_desc *) Tcl_GetHashValue(hashent);
7084 tgl@sss.pgh.pa.us 2747 : 49 : i++;
2748 : :
2749 : : /************************************************************
2750 : : * If a nulls string is given, check for correct length
2751 : : ************************************************************/
9544 bruce@momjian.us 2752 [ - + ]: 49 : if (nulls != NULL)
2753 : : {
9544 bruce@momjian.us 2754 [ # # ]:UBC 0 : if (strlen(nulls) != qdesc->nargs)
2755 : : {
2965 tgl@sss.pgh.pa.us 2756 : 0 : Tcl_SetObjResult(interp,
2757 : : Tcl_NewStringObj("length of nulls string doesn't match number of arguments",
2758 : : -1));
9544 bruce@momjian.us 2759 : 0 : return TCL_ERROR;
2760 : : }
2761 : : }
2762 : :
2763 : : /************************************************************
2764 : : * If there was an argtype list on preparation, we need
2765 : : * an argument value list now
2766 : : ************************************************************/
9544 bruce@momjian.us 2767 [ + + ]:CBC 49 : if (qdesc->nargs > 0)
2768 : : {
2965 tgl@sss.pgh.pa.us 2769 [ - + ]: 45 : if (i >= objc)
2770 : : {
2965 tgl@sss.pgh.pa.us 2771 :UBC 0 : Tcl_SetObjResult(interp,
2772 : : Tcl_NewStringObj("argument list length doesn't match number of arguments for query",
2773 : : -1));
9544 bruce@momjian.us 2774 : 0 : return TCL_ERROR;
2775 : : }
2776 : :
2777 : : /************************************************************
2778 : : * Split the argument values
2779 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2780 [ - + ]:CBC 45 : if (Tcl_ListObjGetElements(interp, objv[i++], &callObjc, &callObjv) != TCL_OK)
9544 bruce@momjian.us 2781 :UBC 0 : return TCL_ERROR;
2782 : :
2783 : : /************************************************************
2784 : : * Check that the number of arguments matches
2785 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 2786 [ - + ]:CBC 45 : if (callObjc != qdesc->nargs)
2787 : : {
2965 tgl@sss.pgh.pa.us 2788 :UBC 0 : Tcl_SetObjResult(interp,
2789 : : Tcl_NewStringObj("argument list length doesn't match number of arguments for query",
2790 : : -1));
9544 bruce@momjian.us 2791 : 0 : return TCL_ERROR;
2792 : : }
2793 : : }
2794 : : else
2965 tgl@sss.pgh.pa.us 2795 :CBC 4 : callObjc = 0;
2796 : :
2797 : : /************************************************************
2798 : : * Get loop body if present
2799 : : ************************************************************/
2800 [ + + ]: 49 : if (i < objc)
2801 : 4 : loop_body = objv[i++];
2802 : :
2803 [ - + ]: 49 : if (i != objc)
2804 : : {
2965 tgl@sss.pgh.pa.us 2805 :UBC 0 : Tcl_WrongNumArgs(interp, 1, objv,
2806 : : "?-count n? ?-array name? ?-nulls string? "
2807 : : "query ?args? ?loop body?");
9544 bruce@momjian.us 2808 : 0 : return TCL_ERROR;
2809 : : }
2810 : :
2811 : : /************************************************************
2812 : : * Execute the plan inside a sub-transaction, so we can cope with
2813 : : * errors sanely
2814 : : ************************************************************/
2815 : :
7084 tgl@sss.pgh.pa.us 2816 :CBC 49 : pltcl_subtrans_begin(oldcontext, oldowner);
2817 : :
7197 2818 [ + - ]: 49 : PG_TRY();
2819 : : {
2820 : : /************************************************************
2821 : : * Setup the value array for SPI_execute_plan() using
2822 : : * the type specific input functions
2823 : : ************************************************************/
2965 2824 : 49 : argvalues = (Datum *) palloc(callObjc * sizeof(Datum));
2825 : :
2826 [ + + ]: 142 : for (j = 0; j < callObjc; j++)
2827 : : {
7084 2828 [ - + - - ]: 93 : if (nulls && nulls[j] == 'n')
2829 : : {
6585 tgl@sss.pgh.pa.us 2830 :UBC 0 : argvalues[j] = InputFunctionCall(&qdesc->arginfuncs[j],
2831 : : NULL,
2832 : 0 : qdesc->argtypioparams[j],
2833 : : -1);
2834 : : }
2835 : : else
2836 : : {
7084 tgl@sss.pgh.pa.us 2837 :CBC 93 : UTF_BEGIN;
6585 2838 : 279 : argvalues[j] = InputFunctionCall(&qdesc->arginfuncs[j],
2489 2839 : 93 : UTF_U2E(Tcl_GetString(callObjv[j])),
6585 2840 : 93 : qdesc->argtypioparams[j],
2841 : : -1);
7084 2842 [ - + ]: 93 : UTF_END;
2843 : : }
2844 : : }
2845 : :
2846 : : /************************************************************
2847 : : * Execute the plan
2848 : : ************************************************************/
2849 : 98 : spi_rc = SPI_execute_plan(qdesc->plan, argvalues, nulls,
2489 2850 : 49 : pltcl_current_call_state->prodesc->fn_readonly,
2851 : : count);
2852 : :
7084 2853 : 49 : my_rc = pltcl_process_SPI_result(interp,
2854 : : arrayname,
2855 : : loop_body,
2856 : : spi_rc,
2857 : : SPI_tuptable,
2858 : : SPI_processed);
2859 : :
2860 : 49 : pltcl_subtrans_commit(oldcontext, oldowner);
2861 : : }
7197 tgl@sss.pgh.pa.us 2862 :UBC 0 : PG_CATCH();
2863 : : {
7084 2864 : 0 : pltcl_subtrans_abort(interp, oldcontext, oldowner);
9544 bruce@momjian.us 2865 : 0 : return TCL_ERROR;
2866 : : }
7197 tgl@sss.pgh.pa.us 2867 [ - + ]:CBC 49 : PG_END_TRY();
2868 : :
2869 : 49 : return my_rc;
2870 : : }
2871 : :
2872 : :
2873 : : /**********************************************************************
2874 : : * pltcl_subtransaction() - Execute some Tcl code in a subtransaction
2875 : : *
2876 : : * The subtransaction is aborted if the Tcl code fragment returns TCL_ERROR,
2877 : : * otherwise it's subcommitted.
2878 : : **********************************************************************/
2879 : : static int
2591 2880 : 8 : pltcl_subtransaction(ClientData cdata, Tcl_Interp *interp,
2881 : : int objc, Tcl_Obj *const objv[])
2882 : : {
2883 : 8 : MemoryContext oldcontext = CurrentMemoryContext;
2884 : 8 : ResourceOwner oldowner = CurrentResourceOwner;
2885 : : int retcode;
2886 : :
2887 [ - + ]: 8 : if (objc != 2)
2888 : : {
2591 tgl@sss.pgh.pa.us 2889 :UBC 0 : Tcl_WrongNumArgs(interp, 1, objv, "command");
2890 : 0 : return TCL_ERROR;
2891 : : }
2892 : :
2893 : : /*
2894 : : * Note: we don't use pltcl_subtrans_begin and friends here because we
2895 : : * don't want the error handling in pltcl_subtrans_abort. But otherwise
2896 : : * the processing should be about the same as in those functions.
2897 : : */
2591 tgl@sss.pgh.pa.us 2898 :CBC 8 : BeginInternalSubTransaction(NULL);
2899 : 8 : MemoryContextSwitchTo(oldcontext);
2900 : :
2901 : 8 : retcode = Tcl_EvalObjEx(interp, objv[1], 0);
2902 : :
2903 [ + + ]: 8 : if (retcode == TCL_ERROR)
2904 : : {
2905 : : /* Rollback the subtransaction */
2906 : 5 : RollbackAndReleaseCurrentSubTransaction();
2907 : : }
2908 : : else
2909 : : {
2910 : : /* Commit the subtransaction */
2911 : 3 : ReleaseCurrentSubTransaction();
2912 : : }
2913 : :
2914 : : /* In either case, restore previous memory context and resource owner */
2915 : 8 : MemoryContextSwitchTo(oldcontext);
2916 : 8 : CurrentResourceOwner = oldowner;
2917 : :
2918 : 8 : return retcode;
2919 : : }
2920 : :
2921 : :
2922 : : /**********************************************************************
2923 : : * pltcl_commit()
2924 : : *
2925 : : * Commit the transaction and start a new one.
2926 : : **********************************************************************/
2927 : : static int
2274 peter_e@gmx.net 2928 : 10 : pltcl_commit(ClientData cdata, Tcl_Interp *interp,
2929 : : int objc, Tcl_Obj *const objv[])
2930 : : {
2931 : 10 : MemoryContext oldcontext = CurrentMemoryContext;
2932 : :
2933 [ + + ]: 10 : PG_TRY();
2934 : : {
2935 : 10 : SPI_commit();
2936 : : }
2937 : 5 : PG_CATCH();
2938 : : {
2939 : : ErrorData *edata;
2940 : :
2941 : : /* Save error info */
2942 : 5 : MemoryContextSwitchTo(oldcontext);
2943 : 5 : edata = CopyErrorData();
2944 : 5 : FlushErrorState();
2945 : :
2946 : : /* Pass the error data to Tcl */
2947 : 5 : pltcl_construct_errorCode(interp, edata);
2948 : 5 : UTF_BEGIN;
2949 : 5 : Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
2950 [ - + ]: 5 : UTF_END;
2951 : 5 : FreeErrorData(edata);
2952 : :
2953 : 5 : return TCL_ERROR;
2954 : : }
2955 [ - + ]: 5 : PG_END_TRY();
2956 : :
2957 : 5 : return TCL_OK;
2958 : : }
2959 : :
2960 : :
2961 : : /**********************************************************************
2962 : : * pltcl_rollback()
2963 : : *
2964 : : * Abort the transaction and start a new one.
2965 : : **********************************************************************/
2966 : : static int
2967 : 6 : pltcl_rollback(ClientData cdata, Tcl_Interp *interp,
2968 : : int objc, Tcl_Obj *const objv[])
2969 : : {
2970 : 6 : MemoryContext oldcontext = CurrentMemoryContext;
2971 : :
2972 [ + + ]: 6 : PG_TRY();
2973 : : {
2974 : 6 : SPI_rollback();
2975 : : }
2976 : 1 : PG_CATCH();
2977 : : {
2978 : : ErrorData *edata;
2979 : :
2980 : : /* Save error info */
2981 : 1 : MemoryContextSwitchTo(oldcontext);
2982 : 1 : edata = CopyErrorData();
2983 : 1 : FlushErrorState();
2984 : :
2985 : : /* Pass the error data to Tcl */
2986 : 1 : pltcl_construct_errorCode(interp, edata);
2987 : 1 : UTF_BEGIN;
2988 : 1 : Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
2989 [ - + ]: 1 : UTF_END;
2990 : 1 : FreeErrorData(edata);
2991 : :
2992 : 1 : return TCL_ERROR;
2993 : : }
2994 [ - + ]: 5 : PG_END_TRY();
2995 : :
2996 : 5 : return TCL_OK;
2997 : : }
2998 : :
2999 : :
3000 : : /**********************************************************************
3001 : : * pltcl_set_tuple_values() - Set variables for all attributes
3002 : : * of a given tuple
3003 : : *
3004 : : * Note: arrayname is presumed to be UTF8; it usually came from Tcl
3005 : : **********************************************************************/
3006 : : static void
2965 tgl@sss.pgh.pa.us 3007 : 50 : pltcl_set_tuple_values(Tcl_Interp *interp, const char *arrayname,
3008 : : uint64 tupno, HeapTuple tuple, TupleDesc tupdesc)
3009 : : {
3010 : : int i;
3011 : : char *outputstr;
3012 : : Datum attr;
3013 : : bool isnull;
3014 : : const char *attname;
3015 : : Oid typoutput;
3016 : : bool typisvarlena;
3017 : : const char **arrptr;
3018 : : const char **nameptr;
3019 : 50 : const char *nullname = NULL;
3020 : :
3021 : : /************************************************************
3022 : : * Prepare pointers for Tcl_SetVar2Ex() below
3023 : : ************************************************************/
9544 bruce@momjian.us 3024 [ + + ]: 50 : if (arrayname == NULL)
3025 : : {
3026 : 28 : arrptr = &attname;
3027 : 28 : nameptr = &nullname;
3028 : : }
3029 : : else
3030 : : {
3031 : 22 : arrptr = &arrayname;
3032 : 22 : nameptr = &attname;
3033 : :
3034 : : /*
3035 : : * When outputting to an array, fill the ".tupno" element with the
3036 : : * current tuple number. This will be overridden below if ".tupno" is
3037 : : * in use as an actual field name in the rowtype.
3038 : : */
2955 tgl@sss.pgh.pa.us 3039 : 22 : Tcl_SetVar2Ex(interp, arrayname, ".tupno", Tcl_NewWideIntObj(tupno), 0);
3040 : : }
3041 : :
9544 bruce@momjian.us 3042 [ + + ]: 120 : for (i = 0; i < tupdesc->natts; i++)
3043 : : {
2429 andres@anarazel.de 3044 : 70 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
3045 : :
3046 : : /* ignore dropped attributes */
3047 [ - + ]: 70 : if (att->attisdropped)
7528 tgl@sss.pgh.pa.us 3048 :UBC 0 : continue;
3049 : :
3050 : : /************************************************************
3051 : : * Get the attribute name
3052 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 3053 :CBC 70 : UTF_BEGIN;
2429 andres@anarazel.de 3054 : 70 : attname = pstrdup(UTF_E2U(NameStr(att->attname)));
2965 tgl@sss.pgh.pa.us 3055 [ - + ]: 70 : UTF_END;
3056 : :
3057 : : /************************************************************
3058 : : * Get the attributes value
3059 : : ************************************************************/
9544 bruce@momjian.us 3060 : 70 : attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
3061 : :
3062 : : /************************************************************
3063 : : * If there is a value, set the variable
3064 : : * If not, unset it
3065 : : *
3066 : : * Hmmm - Null attributes will cause functions to
3067 : : * crash if they don't expect them - need something
3068 : : * smarter here.
3069 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 3070 [ + - ]: 70 : if (!isnull)
3071 : : {
2429 andres@anarazel.de 3072 : 70 : getTypeOutputInfo(att->atttypid, &typoutput, &typisvarlena);
6585 tgl@sss.pgh.pa.us 3073 : 70 : outputstr = OidOutputFunctionCall(typoutput, attr);
8256 bruce@momjian.us 3074 : 70 : UTF_BEGIN;
2965 tgl@sss.pgh.pa.us 3075 : 70 : Tcl_SetVar2Ex(interp, *arrptr, *nameptr,
3076 : 70 : Tcl_NewStringObj(UTF_E2U(outputstr), -1), 0);
8256 bruce@momjian.us 3077 [ - + ]: 70 : UTF_END;
9544 3078 : 70 : pfree(outputstr);
3079 : : }
3080 : : else
9544 bruce@momjian.us 3081 :UBC 0 : Tcl_UnsetVar2(interp, *arrptr, *nameptr, 0);
3082 : :
1902 peter@eisentraut.org 3083 :CBC 70 : pfree(unconstify(char *, attname));
3084 : : }
9544 bruce@momjian.us 3085 : 50 : }
3086 : :
3087 : :
3088 : : /**********************************************************************
3089 : : * pltcl_build_tuple_argument() - Build a list object usable for 'array set'
3090 : : * from all attributes of a given tuple
3091 : : **********************************************************************/
3092 : : static Tcl_Obj *
1842 peter@eisentraut.org 3093 : 69 : pltcl_build_tuple_argument(HeapTuple tuple, TupleDesc tupdesc, bool include_generated)
3094 : : {
2965 tgl@sss.pgh.pa.us 3095 : 69 : Tcl_Obj *retobj = Tcl_NewObj();
3096 : : int i;
3097 : : char *outputstr;
3098 : : Datum attr;
3099 : : bool isnull;
3100 : : char *attname;
3101 : : Oid typoutput;
3102 : : bool typisvarlena;
3103 : :
9544 bruce@momjian.us 3104 [ + + ]: 284 : for (i = 0; i < tupdesc->natts; i++)
3105 : : {
2429 andres@anarazel.de 3106 : 215 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
3107 : :
3108 : : /* ignore dropped attributes */
3109 [ + + ]: 215 : if (att->attisdropped)
7528 tgl@sss.pgh.pa.us 3110 : 8 : continue;
3111 : :
1842 peter@eisentraut.org 3112 [ + + ]: 207 : if (att->attgenerated)
3113 : : {
3114 : : /* don't include unless requested */
3115 [ + + ]: 9 : if (!include_generated)
3116 : 3 : continue;
3117 : : }
3118 : :
3119 : : /************************************************************
3120 : : * Get the attribute name
3121 : : ************************************************************/
2429 andres@anarazel.de 3122 : 204 : attname = NameStr(att->attname);
3123 : :
3124 : : /************************************************************
3125 : : * Get the attributes value
3126 : : ************************************************************/
9544 bruce@momjian.us 3127 : 204 : attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
3128 : :
3129 : : /************************************************************
3130 : : * If there is a value, append the attribute name and the
3131 : : * value to the list
3132 : : *
3133 : : * Hmmm - Null attributes will cause functions to
3134 : : * crash if they don't expect them - need something
3135 : : * smarter here.
3136 : : ************************************************************/
2965 tgl@sss.pgh.pa.us 3137 [ + + ]: 204 : if (!isnull)
3138 : : {
2429 andres@anarazel.de 3139 : 200 : getTypeOutputInfo(att->atttypid,
3140 : : &typoutput, &typisvarlena);
6585 tgl@sss.pgh.pa.us 3141 : 200 : outputstr = OidOutputFunctionCall(typoutput, attr);
8256 bruce@momjian.us 3142 : 200 : UTF_BEGIN;
2965 tgl@sss.pgh.pa.us 3143 : 200 : Tcl_ListObjAppendElement(NULL, retobj,
3144 : 200 : Tcl_NewStringObj(UTF_E2U(attname), -1));
3145 [ - + ]: 200 : UTF_END;
3146 : 200 : UTF_BEGIN;
3147 : 200 : Tcl_ListObjAppendElement(NULL, retobj,
2489 3148 : 200 : Tcl_NewStringObj(UTF_E2U(outputstr), -1));
8256 bruce@momjian.us 3149 [ - + ]: 200 : UTF_END;
9544 3150 : 200 : pfree(outputstr);
3151 : : }
3152 : : }
3153 : :
2965 tgl@sss.pgh.pa.us 3154 : 69 : return retobj;
3155 : : }
3156 : :
3157 : : /**********************************************************************
3158 : : * pltcl_build_tuple_result() - Build a tuple of function's result rowtype
3159 : : * from a Tcl list of column names and values
3160 : : *
3161 : : * In a trigger function, we build a tuple of the trigger table's rowtype.
3162 : : *
3163 : : * Note: this function leaks memory. Even if we made it clean up its own
3164 : : * mess, there's no way to prevent the datatype input functions it calls
3165 : : * from leaking. Run it in a short-lived context, unless we're about to
3166 : : * exit the procedure anyway.
3167 : : **********************************************************************/
3168 : : static HeapTuple
2716 3169 : 31 : pltcl_build_tuple_result(Tcl_Interp *interp, Tcl_Obj **kvObjv, int kvObjc,
3170 : : pltcl_call_state *call_state)
3171 : : {
3172 : : HeapTuple tuple;
3173 : : TupleDesc tupdesc;
3174 : : AttInMetadata *attinmeta;
3175 : : char **values;
3176 : : int i;
3177 : :
2655 3178 [ + + ]: 31 : if (call_state->ret_tupdesc)
3179 : : {
3180 : 21 : tupdesc = call_state->ret_tupdesc;
3181 : 21 : attinmeta = call_state->attinmeta;
3182 : : }
3183 [ + - ]: 10 : else if (call_state->trigdata)
3184 : : {
3185 : 10 : tupdesc = RelationGetDescr(call_state->trigdata->tg_relation);
3186 : 10 : attinmeta = TupleDescGetAttInMetadata(tupdesc);
3187 : : }
3188 : : else
3189 : : {
2655 tgl@sss.pgh.pa.us 3190 [ # # ]:UBC 0 : elog(ERROR, "PL/Tcl function does not return a tuple");
3191 : : tupdesc = NULL; /* keep compiler quiet */
3192 : : attinmeta = NULL;
3193 : : }
3194 : :
2655 tgl@sss.pgh.pa.us 3195 :CBC 31 : values = (char **) palloc0(tupdesc->natts * sizeof(char *));
3196 : :
2716 3197 [ + + ]: 31 : if (kvObjc % 2 != 0)
3198 [ + - ]: 2 : ereport(ERROR,
3199 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3200 : : errmsg("column name/value list must have even number of elements")));
3201 : :
3202 [ + + ]: 98 : for (i = 0; i < kvObjc; i += 2)
3203 : : {
2655 3204 : 73 : char *fieldName = utf_u2e(Tcl_GetString(kvObjv[i]));
3205 : 73 : int attn = SPI_fnumber(tupdesc, fieldName);
3206 : :
3207 : : /*
3208 : : * We silently ignore ".tupno", if it's present but doesn't match any
3209 : : * actual output column. This allows direct use of a row returned by
3210 : : * pltcl_set_tuple_values().
3211 : : */
2716 3212 [ + + ]: 73 : if (attn == SPI_ERROR_NOATTRIBUTE)
3213 : : {
3214 [ - + ]: 3 : if (strcmp(fieldName, ".tupno") == 0)
2716 tgl@sss.pgh.pa.us 3215 :UBC 0 : continue;
2716 tgl@sss.pgh.pa.us 3216 [ + - ]:CBC 3 : ereport(ERROR,
3217 : : (errcode(ERRCODE_UNDEFINED_COLUMN),
3218 : : errmsg("column name/value list contains nonexistent column name \"%s\"",
3219 : : fieldName)));
3220 : : }
3221 : :
3222 [ - + ]: 70 : if (attn <= 0)
2716 tgl@sss.pgh.pa.us 3223 [ # # ]:UBC 0 : ereport(ERROR,
3224 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3225 : : errmsg("cannot set system attribute \"%s\"",
3226 : : fieldName)));
3227 : :
1842 peter@eisentraut.org 3228 [ + + ]:CBC 70 : if (TupleDescAttr(tupdesc, attn - 1)->attgenerated)
3229 [ + - ]: 1 : ereport(ERROR,
3230 : : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
3231 : : errmsg("cannot set generated column \"%s\"",
3232 : : fieldName)));
3233 : :
2655 tgl@sss.pgh.pa.us 3234 : 69 : values[attn - 1] = utf_u2e(Tcl_GetString(kvObjv[i + 1]));
3235 : : }
3236 : :
2362 3237 : 25 : tuple = BuildTupleFromCStrings(attinmeta, values);
3238 : :
3239 : : /* if result type is domain-over-composite, check domain constraints */
3240 [ + + ]: 25 : if (call_state->prodesc->fn_retisdomain)
3241 : 3 : domain_check(HeapTupleGetDatum(tuple), false,
3242 : 3 : call_state->prodesc->result_typid,
3243 : 3 : &call_state->prodesc->domain_info,
3244 : 3 : call_state->prodesc->fn_cxt);
3245 : :
3246 : 24 : return tuple;
3247 : : }
3248 : :
3249 : : /**********************************************************************
3250 : : * pltcl_init_tuple_store() - Initialize the result tuplestore for a SRF
3251 : : **********************************************************************/
3252 : : static void
2716 3253 : 5 : pltcl_init_tuple_store(pltcl_call_state *call_state)
3254 : : {
3255 : 5 : ReturnSetInfo *rsi = call_state->rsi;
3256 : : MemoryContext oldcxt;
3257 : : ResourceOwner oldowner;
3258 : :
3259 : : /* Should be in a SRF */
3260 [ - + ]: 5 : Assert(rsi);
3261 : : /* Should be first time through */
3262 [ - + ]: 5 : Assert(!call_state->tuple_store);
3263 [ - + ]: 5 : Assert(!call_state->attinmeta);
3264 : :
3265 : : /* We expect caller to provide an appropriate result tupdesc */
3266 [ - + ]: 5 : Assert(rsi->expectedDesc);
3267 : 5 : call_state->ret_tupdesc = rsi->expectedDesc;
3268 : :
3269 : : /*
3270 : : * Switch to the right memory context and resource owner for storing the
3271 : : * tuplestore. If we're within a subtransaction opened for an exception
3272 : : * block, for example, we must still create the tuplestore in the resource
3273 : : * owner that was active when this function was entered, and not in the
3274 : : * subtransaction's resource owner.
3275 : : */
3276 : 5 : oldcxt = MemoryContextSwitchTo(call_state->tuple_store_cxt);
3277 : 5 : oldowner = CurrentResourceOwner;
3278 : 5 : CurrentResourceOwner = call_state->tuple_store_owner;
3279 : :
3280 : 5 : call_state->tuple_store =
3281 : 5 : tuplestore_begin_heap(rsi->allowedModes & SFRM_Materialize_Random,
3282 : : false, work_mem);
3283 : :
3284 : : /* Build attinmeta in this context, too */
3285 : 5 : call_state->attinmeta = TupleDescGetAttInMetadata(call_state->ret_tupdesc);
3286 : :
3287 : 5 : CurrentResourceOwner = oldowner;
3288 : 5 : MemoryContextSwitchTo(oldcxt);
3289 : 5 : }
|
