PostgreSQL Source Code git master
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Functions | Variables
pltcl.c File Reference
#include "postgres.h"
#include <tcl.h>
#include <unistd.h>
#include <fcntl.h>
#include "access/htup_details.h"
#include "access/xact.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "commands/event_trigger.h"
#include "commands/trigger.h"
#include "executor/spi.h"
#include "fmgr.h"
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "parser/parse_func.h"
#include "parser/parse_type.h"
#include "pgstat.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/hsearch.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/regproc.h"
#include "utils/rel.h"
#include "utils/syscache.h"
#include "utils/tuplestore.h"
#include "utils/typcache.h"
#include "pltclerrcodes.h"
Include dependency graph for pltcl.c:

Go to the source code of this file.

Data Structures

struct  pltcl_interp_desc
 
struct  pltcl_proc_desc
 
struct  pltcl_query_desc
 
struct  pltcl_proc_key
 
struct  pltcl_proc_ptr
 
struct  pltcl_call_state
 
struct  TclExceptionNameMap
 

Macros

#define HAVE_TCL_VERSION(maj, min)
 
#define CONST86
 
#define TEXTDOMAIN   PG_TEXTDOMAIN("pltcl")
 
#define UTF_BEGIN
 
#define UTF_END
 
#define UTF_U2E(x)    (_pltcl_utf_dst = utf_u2e(_pltcl_utf_src = (x)))
 
#define UTF_E2U(x)    (_pltcl_utf_dst = utf_e2u(_pltcl_utf_src = (x)))
 

Typedefs

typedef int Tcl_Size
 
typedef struct pltcl_interp_desc pltcl_interp_desc
 
typedef struct pltcl_proc_desc pltcl_proc_desc
 
typedef struct pltcl_query_desc pltcl_query_desc
 
typedef struct pltcl_proc_key pltcl_proc_key
 
typedef struct pltcl_proc_ptr pltcl_proc_ptr
 
typedef struct pltcl_call_state pltcl_call_state
 

Functions

 PG_MODULE_MAGIC_EXT (.name="pltcl",.version=PG_VERSION)
 
static char * utf_u2e (const char *src)
 
static char * utf_e2u (const char *src)
 
static void pltcl_init_interp (pltcl_interp_desc *interp_desc, Oid prolang, bool pltrusted)
 
static pltcl_interp_desc * pltcl_fetch_interp (Oid prolang, bool pltrusted)
 
static void call_pltcl_start_proc (Oid prolang, bool pltrusted)
 
static void start_proc_error_callback (void *arg)
 
static Datum pltcl_handler (PG_FUNCTION_ARGS, bool pltrusted)
 
static Datum pltcl_func_handler (PG_FUNCTION_ARGS, pltcl_call_state *call_state, bool pltrusted)
 
static HeapTuple pltcl_trigger_handler (PG_FUNCTION_ARGS, pltcl_call_state *call_state, bool pltrusted)
 
static void pltcl_event_trigger_handler (PG_FUNCTION_ARGS, pltcl_call_state *call_state, bool pltrusted)
 
static void throw_tcl_error (Tcl_Interp *interp, const char *proname)
 
static pltcl_proc_desc * compile_pltcl_function (Oid fn_oid, Oid tgreloid, bool is_event_trigger, bool pltrusted)
 
static int pltcl_elog (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static void pltcl_construct_errorCode (Tcl_Interp *interp, ErrorData *edata)
 
static const char * pltcl_get_condition_name (int sqlstate)
 
static int pltcl_quote (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_argisnull (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_returnnull (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_returnnext (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_SPI_execute (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_process_SPI_result (Tcl_Interp *interp, const char *arrayname, Tcl_Obj *loop_body, int spi_rc, SPITupleTable *tuptable, uint64 ntuples)
 
static int pltcl_SPI_prepare (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_SPI_execute_plan (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_subtransaction (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_commit (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static int pltcl_rollback (ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 
static void pltcl_subtrans_begin (MemoryContext oldcontext, ResourceOwner oldowner)
 
static void pltcl_subtrans_commit (MemoryContext oldcontext, ResourceOwner oldowner)
 
static void pltcl_subtrans_abort (Tcl_Interp *interp, MemoryContext oldcontext, ResourceOwner oldowner)
 
static void pltcl_set_tuple_values (Tcl_Interp *interp, const char *arrayname, uint64 tupno, HeapTuple tuple, TupleDesc tupdesc)
 
static Tcl_Obj * pltcl_build_tuple_argument (HeapTuple tuple, TupleDesc tupdesc, bool include_generated)
 
static HeapTuple pltcl_build_tuple_result (Tcl_Interp *interp, Tcl_Obj **kvObjv, int kvObjc, pltcl_call_state *call_state)
 
static void pltcl_init_tuple_store (pltcl_call_state *call_state)
 
static ClientData pltcl_InitNotifier (void)
 
static void pltcl_FinalizeNotifier (ClientData clientData)
 
static void pltcl_SetTimer (CONST86 Tcl_Time *timePtr)
 
static void pltcl_AlertNotifier (ClientData clientData)
 
static void pltcl_CreateFileHandler (int fd, int mask, Tcl_FileProc *proc, ClientData clientData)
 
static void pltcl_DeleteFileHandler (int fd)
 
static void pltcl_ServiceModeHook (int mode)
 
static int pltcl_WaitForEvent (CONST86 Tcl_Time *timePtr)
 
void _PG_init (void)
 
 PG_FUNCTION_INFO_V1 (pltcl_call_handler)
 
Datum pltcl_call_handler (PG_FUNCTION_ARGS)
 
 PG_FUNCTION_INFO_V1 (pltclu_call_handler)
 
Datum pltclu_call_handler (PG_FUNCTION_ARGS)
 

Variables

static char * pltcl_start_proc = NULL
 
static char * pltclu_start_proc = NULL
 
static bool pltcl_pm_init_done = false
 
static Tcl_Interp * pltcl_hold_interp = NULL
 
static HTAB * pltcl_interp_htab = NULL
 
static HTAB * pltcl_proc_htab = NULL
 
static pltcl_call_state * pltcl_current_call_state = NULL
 
static const TclExceptionNameMap exception_name_map []
 

Macro Definition Documentation

◆ CONST86

#define CONST86

Definition at line 60 of file pltcl.c.

◆ HAVE_TCL_VERSION

#define HAVE_TCL_VERSION (   maj,
  min 
)
Value:
((TCL_MAJOR_VERSION > maj) || \
(TCL_MAJOR_VERSION == maj && TCL_MINOR_VERSION >= min))
fb
static int fb(int x)
Definition preproc-init.c:92

Definition at line 49 of file pltcl.c.

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

◆ TEXTDOMAIN

#define TEXTDOMAIN   PG_TEXTDOMAIN("pltcl")

Definition at line 69 of file pltcl.c.

◆ UTF_BEGIN

#define UTF_BEGIN
Value:
do { \
const char *_pltcl_utf_src = NULL; \
char *_pltcl_utf_dst = NULL

Definition at line 94 of file pltcl.c.

95 { \
96 const char *_pltcl_utf_src = NULL; \
97 char *_pltcl_utf_dst = NULL

◆ UTF_E2U

#define UTF_E2U (   x)     (_pltcl_utf_dst = utf_e2u(_pltcl_utf_src = (x)))

Definition at line 107 of file pltcl.c.

◆ UTF_END

#define UTF_END
Value:
if (_pltcl_utf_src != (const char *) _pltcl_utf_dst) \
pfree(_pltcl_utf_dst); \
} while (0)

Definition at line 99 of file pltcl.c.

◆ UTF_U2E

#define UTF_U2E (   x)     (_pltcl_utf_dst = utf_u2e(_pltcl_utf_src = (x)))

Definition at line 104 of file pltcl.c.

Typedef Documentation

◆ pltcl_call_state

typedef struct pltcl_call_state pltcl_call_state

◆ pltcl_interp_desc

typedef struct pltcl_interp_desc pltcl_interp_desc

◆ pltcl_proc_desc

typedef struct pltcl_proc_desc pltcl_proc_desc

◆ pltcl_proc_key

typedef struct pltcl_proc_key pltcl_proc_key

◆ pltcl_proc_ptr

typedef struct pltcl_proc_ptr pltcl_proc_ptr

◆ pltcl_query_desc

typedef struct pltcl_query_desc pltcl_query_desc

◆ Tcl_Size

typedef int Tcl_Size

Definition at line 64 of file pltcl.c.

Function Documentation

◆ _PG_init()

void _PG_init ( void  )

Definition at line 410 of file pltcl.c.

411{
412 Tcl_NotifierProcs notifier;
413 HASHCTL hash_ctl;
414
415 /* Be sure we do initialization only once (should be redundant now) */
416 if (pltcl_pm_init_done)
417 return;
418
419 pg_bindtextdomain(TEXTDOMAIN);
420
421#ifdef WIN32
422 /* Required on win32 to prevent error loading init.tcl */
423 Tcl_FindExecutable("");
424#endif
425
426 /*
427 * Override the functions in the Notifier subsystem. See comments above.
428 */
429 notifier.setTimerProc = pltcl_SetTimer;
430 notifier.waitForEventProc = pltcl_WaitForEvent;
431 notifier.createFileHandlerProc = pltcl_CreateFileHandler;
432 notifier.deleteFileHandlerProc = pltcl_DeleteFileHandler;
433 notifier.initNotifierProc = pltcl_InitNotifier;
434 notifier.finalizeNotifierProc = pltcl_FinalizeNotifier;
435 notifier.alertNotifierProc = pltcl_AlertNotifier;
436 notifier.serviceModeHookProc = pltcl_ServiceModeHook;
437 Tcl_SetNotifier(&notifier);
438
439 /************************************************************
440 * Create the dummy hold interpreter to prevent close of
441 * stdout and stderr on DeleteInterp
442 ************************************************************/
443 if ((pltcl_hold_interp = Tcl_CreateInterp()) == NULL)
444 elog(ERROR, "could not create dummy Tcl interpreter");
445 if (Tcl_Init(pltcl_hold_interp) == TCL_ERROR)
446 elog(ERROR, "could not initialize dummy Tcl interpreter");
447
448 /************************************************************
449 * Create the hash table for working interpreters
450 ************************************************************/
451 hash_ctl.keysize = sizeof(Oid);
452 hash_ctl.entrysize = sizeof(pltcl_interp_desc);
453 pltcl_interp_htab = hash_create("PL/Tcl interpreters",
454 8,
455 &hash_ctl,
456 HASH_ELEM | HASH_BLOBS);
457
458 /************************************************************
459 * Create the hash table for function lookup
460 ************************************************************/
461 hash_ctl.keysize = sizeof(pltcl_proc_key);
462 hash_ctl.entrysize = sizeof(pltcl_proc_ptr);
463 pltcl_proc_htab = hash_create("PL/Tcl functions",
464 100,
465 &hash_ctl,
466 HASH_ELEM | HASH_BLOBS);
467
468 /************************************************************
469 * Define PL/Tcl's custom GUCs
470 ************************************************************/
471 DefineCustomStringVariable("pltcl.start_proc",
472 gettext_noop("PL/Tcl function to call once when pltcl is first used."),
473 NULL,
474 &pltcl_start_proc,
475 NULL,
476 PGC_SUSET, 0,
477 NULL, NULL, NULL);
478 DefineCustomStringVariable("pltclu.start_proc",
479 gettext_noop("PL/TclU function to call once when pltclu is first used."),
480 NULL,
481 &pltclu_start_proc,
482 NULL,
483 PGC_SUSET, 0,
484 NULL, NULL, NULL);
485
486 MarkGUCPrefixReserved("pltcl");
487 MarkGUCPrefixReserved("pltclu");
488
489 pltcl_pm_init_done = true;
490}

References DefineCustomStringVariable(), elog, ERROR, fb(), gettext_noop, HASH_BLOBS, hash_create(), HASH_ELEM, MarkGUCPrefixReserved(), pg_bindtextdomain(), PGC_SUSET, pltcl_AlertNotifier(), pltcl_CreateFileHandler(), pltcl_DeleteFileHandler(), pltcl_FinalizeNotifier(), pltcl_hold_interp, pltcl_InitNotifier(), pltcl_interp_htab, pltcl_pm_init_done, pltcl_proc_htab, pltcl_ServiceModeHook(), pltcl_SetTimer(), pltcl_start_proc, pltcl_WaitForEvent(), pltclu_start_proc, and TEXTDOMAIN.

◆ call_pltcl_start_proc()

static void call_pltcl_start_proc ( Oid  prolang,
bool  pltrusted 
)
static

Definition at line 599 of file pltcl.c.

600{
601 LOCAL_FCINFO(fcinfo, 0);
602 char *start_proc;
603 const char *gucname;
604 ErrorContextCallback errcallback;
605 List *namelist;
606 Oid procOid;
607 HeapTuple procTup;
608 Form_pg_proc procStruct;
609 AclResult aclresult;
610 FmgrInfo finfo;
611 PgStat_FunctionCallUsage fcusage;
612
613 /* select appropriate GUC */
614 start_proc = pltrusted ? pltcl_start_proc : pltclu_start_proc;
615 gucname = pltrusted ? "pltcl.start_proc" : "pltclu.start_proc";
616
617 /* Nothing to do if it's empty or unset */
618 if (start_proc == NULL || start_proc[0] == '\0')
619 return;
620
621 /* Set up errcontext callback to make errors more helpful */
622 errcallback.callback = start_proc_error_callback;
623 errcallback.arg = unconstify(char *, gucname);
624 errcallback.previous = error_context_stack;
625 error_context_stack = &errcallback;
626
627 /* Parse possibly-qualified identifier and look up the function */
628 namelist = stringToQualifiedNameList(start_proc, NULL);
629 procOid = LookupFuncName(namelist, 0, NULL, false);
630
631 /* Current user must have permission to call function */
632 aclresult = object_aclcheck(ProcedureRelationId, procOid, GetUserId(), ACL_EXECUTE);
633 if (aclresult != ACLCHECK_OK)
634 aclcheck_error(aclresult, OBJECT_FUNCTION, start_proc);
635
636 /* Get the function's pg_proc entry */
637 procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procOid));
638 if (!HeapTupleIsValid(procTup))
639 elog(ERROR, "cache lookup failed for function %u", procOid);
640 procStruct = (Form_pg_proc) GETSTRUCT(procTup);
641
642 /* It must be same language as the function we're currently calling */
643 if (procStruct->prolang != prolang)
644 ereport(ERROR,
645 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
646 errmsg("function \"%s\" is in the wrong language",
647 start_proc)));
648
649 /*
650 * It must not be SECURITY DEFINER, either. This together with the
651 * language match check ensures that the function will execute in the same
652 * Tcl interpreter we just finished initializing.
653 */
654 if (procStruct->prosecdef)
655 ereport(ERROR,
656 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
657 errmsg("function \"%s\" must not be SECURITY DEFINER",
658 start_proc)));
659
660 /* A-OK */
661 ReleaseSysCache(procTup);
662
663 /*
664 * Call the function using the normal SQL function call mechanism. We
665 * could perhaps cheat and jump directly to pltcl_handler(), but it seems
666 * better to do it this way so that the call is exposed to, eg, call
667 * statistics collection.
668 */
669 InvokeFunctionExecuteHook(procOid);
670 fmgr_info(procOid, &finfo);
671 InitFunctionCallInfoData(*fcinfo, &finfo,
672 0,
673 InvalidOid, NULL, NULL);
674 pgstat_init_function_usage(fcinfo, &fcusage);
675 (void) FunctionCallInvoke(fcinfo);
676 pgstat_end_function_usage(&fcusage, true);
677
678 /* Pop the error context stack */
679 error_context_stack = errcallback.previous;
680}

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, ErrorContextCallback::arg, ErrorContextCallback::callback, elog, ereport, errcode(), errmsg, ERROR, error_context_stack, fb(), fmgr_info(), Form_pg_proc, FunctionCallInvoke, GETSTRUCT(), GetUserId(), HeapTupleIsValid, InitFunctionCallInfoData, InvalidOid, InvokeFunctionExecuteHook, LOCAL_FCINFO, LookupFuncName(), object_aclcheck(), OBJECT_FUNCTION, ObjectIdGetDatum(), pgstat_end_function_usage(), pgstat_init_function_usage(), pltcl_start_proc, pltclu_start_proc, ErrorContextCallback::previous, ReleaseSysCache(), SearchSysCache1(), start_proc_error_callback(), stringToQualifiedNameList(), and unconstify.

Referenced by pltcl_init_interp().

◆ compile_pltcl_function()

static pltcl_proc_desc * compile_pltcl_function ( Oid  fn_oid,
Oid  tgreloid,
bool  is_event_trigger,
bool  pltrusted 
)
static

Definition at line 1419 of file pltcl.c.

1421{
1422 HeapTuple procTup;
1423 Form_pg_proc procStruct;
1424 pltcl_proc_key proc_key;
1425 pltcl_proc_ptr *proc_ptr;
1426 bool found;
1427 pltcl_proc_desc *prodesc;
1428 pltcl_proc_desc *old_prodesc;
1429 volatile MemoryContext proc_cxt = NULL;
1430 Tcl_DString proc_internal_def;
1431 Tcl_DString proc_internal_name;
1432 Tcl_DString proc_internal_body;
1433
1434 /* We'll need the pg_proc tuple in any case... */
1435 procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fn_oid));
1436 if (!HeapTupleIsValid(procTup))
1437 elog(ERROR, "cache lookup failed for function %u", fn_oid);
1438 procStruct = (Form_pg_proc) GETSTRUCT(procTup);
1439
1440 /*
1441 * Look up function in pltcl_proc_htab; if it's not there, create an entry
1442 * and set the entry's proc_ptr to NULL.
1443 */
1444 proc_key.proc_id = fn_oid;
1445 proc_key.is_trigger = OidIsValid(tgreloid);
1446 proc_key.user_id = pltrusted ? GetUserId() : InvalidOid;
1447
1448 proc_ptr = hash_search(pltcl_proc_htab, &proc_key,
1449 HASH_ENTER,
1450 &found);
1451 if (!found)
1452 proc_ptr->proc_ptr = NULL;
1453
1454 prodesc = proc_ptr->proc_ptr;
1455
1456 /************************************************************
1457 * If it's present, must check whether it's still up to date.
1458 * This is needed because CREATE OR REPLACE FUNCTION can modify the
1459 * function's pg_proc entry without changing its OID.
1460 ************************************************************/
1461 if (prodesc != NULL &&
1462 prodesc->internal_proname != NULL &&
1463 prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
1464 ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self))
1465 {
1466 /* It's still up-to-date, so we can use it */
1467 ReleaseSysCache(procTup);
1468 return prodesc;
1469 }
1470
1471 /************************************************************
1472 * If we haven't found it in the hashtable, we analyze
1473 * the functions arguments and returntype and store
1474 * the in-/out-functions in the prodesc block and create
1475 * a new hashtable entry for it.
1476 *
1477 * Then we load the procedure into the Tcl interpreter.
1478 ************************************************************/
1479 Tcl_DStringInit(&proc_internal_def);
1480 Tcl_DStringInit(&proc_internal_name);
1481 Tcl_DStringInit(&proc_internal_body);
1482 PG_TRY();
1483 {
1484 bool is_trigger = OidIsValid(tgreloid);
1485 Tcl_CmdInfo cmdinfo;
1486 const char *user_proname;
1487 const char *internal_proname;
1488 bool need_underscore;
1489 HeapTuple typeTup;
1490 Form_pg_type typeStruct;
1491 char proc_internal_args[33 * FUNC_MAX_ARGS];
1492 Datum prosrcdatum;
1493 char *proc_source;
1494 char buf[48];
1495 pltcl_interp_desc *interp_desc;
1496 Tcl_Interp *interp;
1497 int i;
1498 int tcl_rc;
1499 MemoryContext oldcontext;
1500
1501 /************************************************************
1502 * Identify the interpreter to use for the function
1503 ************************************************************/
1504 interp_desc = pltcl_fetch_interp(procStruct->prolang, pltrusted);
1505 interp = interp_desc->interp;
1506
1507 /************************************************************
1508 * If redefining the function, try to remove the old internal
1509 * procedure from Tcl's namespace. The point of this is partly to
1510 * allow re-use of the same internal proc name, and partly to avoid
1511 * leaking the Tcl procedure object if we end up not choosing the same
1512 * name. We assume that Tcl is smart enough to not physically delete
1513 * the procedure object if it's currently being executed.
1514 ************************************************************/
1515 if (prodesc != NULL &&
1516 prodesc->internal_proname != NULL)
1517 {
1518 /* We simply ignore any error */
1519 (void) Tcl_DeleteCommand(interp, prodesc->internal_proname);
1520 /* Don't do this more than once */
1521 prodesc->internal_proname = NULL;
1522 }
1523
1524 /************************************************************
1525 * Build the proc name we'll use in error messages.
1526 ************************************************************/
1527 user_proname = format_procedure(fn_oid);
1528
1529 /************************************************************
1530 * Build the internal proc name from the user_proname and/or OID.
1531 * The internal name must be all-ASCII since we don't want to deal
1532 * with encoding conversions. We don't want to worry about Tcl
1533 * quoting rules either, so use only the characters of the function
1534 * name that are ASCII alphanumerics, plus underscores to separate
1535 * function name and arguments. If what we end up with isn't
1536 * unique (that is, it matches some existing Tcl command name),
1537 * append the function OID (perhaps repeatedly) so that it is unique.
1538 ************************************************************/
1539
1540 /* For historical reasons, use a function-type-specific prefix */
1541 if (is_event_trigger)
1542 Tcl_DStringAppend(&proc_internal_name,
1543 "__PLTcl_evttrigger_", -1);
1544 else if (is_trigger)
1545 Tcl_DStringAppend(&proc_internal_name,
1546 "__PLTcl_trigger_", -1);
1547 else
1548 Tcl_DStringAppend(&proc_internal_name,
1549 "__PLTcl_proc_", -1);
1550 /* Now add what we can from the user_proname */
1551 need_underscore = false;
1552 for (const char *ptr = user_proname; *ptr; ptr++)
1553 {
1554 if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1555 "abcdefghijklmnopqrstuvwxyz"
1556 "0123456789_", *ptr) != NULL)
1557 {
1558 /* Done this way to avoid adding a trailing underscore */
1559 if (need_underscore)
1560 {
1561 Tcl_DStringAppend(&proc_internal_name, "_", 1);
1562 need_underscore = false;
1563 }
1564 Tcl_DStringAppend(&proc_internal_name, ptr, 1);
1565 }
1566 else if (strchr("(, ", *ptr) != NULL)
1567 need_underscore = true;
1568 }
1569 /* If this name already exists, append fn_oid; repeat as needed */
1570 while (Tcl_GetCommandInfo(interp,
1571 Tcl_DStringValue(&proc_internal_name),
1572 &cmdinfo))
1573 {
1574 snprintf(buf, sizeof(buf), "_%u", fn_oid);
1575 Tcl_DStringAppend(&proc_internal_name, buf, -1);
1576 }
1577 internal_proname = Tcl_DStringValue(&proc_internal_name);
1578
1579 /************************************************************
1580 * Allocate a context that will hold all PG data for the procedure.
1581 ************************************************************/
1582 proc_cxt = AllocSetContextCreate(TopMemoryContext,
1583 "PL/Tcl function",
1584 ALLOCSET_SMALL_SIZES);
1585
1586 /************************************************************
1587 * Allocate and fill a new procedure description block.
1588 * struct prodesc and subsidiary data must all live in proc_cxt.
1589 ************************************************************/
1590 oldcontext = MemoryContextSwitchTo(proc_cxt);
1591 prodesc = palloc0_object(pltcl_proc_desc);
1592 prodesc->user_proname = pstrdup(user_proname);
1593 MemoryContextSetIdentifier(proc_cxt, prodesc->user_proname);
1594 prodesc->internal_proname = pstrdup(internal_proname);
1595 prodesc->fn_cxt = proc_cxt;
1596 prodesc->fn_refcount = 0;
1597 prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
1598 prodesc->fn_tid = procTup->t_self;
1599 prodesc->nargs = procStruct->pronargs;
1600 prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
1601 prodesc->arg_is_rowtype = (bool *) palloc0(prodesc->nargs * sizeof(bool));
1602 MemoryContextSwitchTo(oldcontext);
1603
1604 /* Remember if function is STABLE/IMMUTABLE */
1605 prodesc->fn_readonly =
1606 (procStruct->provolatile != PROVOLATILE_VOLATILE);
1607 /* And whether it is trusted */
1608 prodesc->lanpltrusted = pltrusted;
1609 /* Save the associated interpreter, too */
1610 prodesc->interp_desc = interp_desc;
1611
1612 /************************************************************
1613 * Get the required information for input conversion of the
1614 * return value.
1615 ************************************************************/
1616 if (!is_trigger && !is_event_trigger)
1617 {
1618 Oid rettype = procStruct->prorettype;
1619
1620 typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(rettype));
1621 if (!HeapTupleIsValid(typeTup))
1622 elog(ERROR, "cache lookup failed for type %u", rettype);
1623 typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
1624
1625 /* Disallow pseudotype result, except VOID and RECORD */
1626 if (typeStruct->typtype == TYPTYPE_PSEUDO)
1627 {
1628 if (rettype == VOIDOID ||
1629 rettype == RECORDOID)
1630 /* okay */ ;
1631 else if (rettype == TRIGGEROID ||
1632 rettype == EVENT_TRIGGEROID)
1633 ereport(ERROR,
1634 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1635 errmsg("trigger functions can only be called as triggers")));
1636 else
1637 ereport(ERROR,
1638 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1639 errmsg("PL/Tcl functions cannot return type %s",
1640 format_type_be(rettype))));
1641 }
1642
1643 prodesc->result_typid = rettype;
1644 fmgr_info_cxt(typeStruct->typinput,
1645 &(prodesc->result_in_func),
1646 proc_cxt);
1647 prodesc->result_typioparam = getTypeIOParam(typeTup);
1648
1649 prodesc->fn_retisset = procStruct->proretset;
1650 prodesc->fn_retistuple = type_is_rowtype(rettype);
1651 prodesc->fn_retisdomain = (typeStruct->typtype == TYPTYPE_DOMAIN);
1652 prodesc->domain_info = NULL;
1653
1654 ReleaseSysCache(typeTup);
1655 }
1656
1657 /************************************************************
1658 * Get the required information for output conversion
1659 * of all procedure arguments, and set up argument naming info.
1660 ************************************************************/
1661 if (!is_trigger && !is_event_trigger)
1662 {
1663 proc_internal_args[0] = '\0';
1664 for (i = 0; i < prodesc->nargs; i++)
1665 {
1666 Oid argtype = procStruct->proargtypes.values[i];
1667
1668 typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(argtype));
1669 if (!HeapTupleIsValid(typeTup))
1670 elog(ERROR, "cache lookup failed for type %u", argtype);
1671 typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
1672
1673 /* Disallow pseudotype argument, except RECORD */
1674 if (typeStruct->typtype == TYPTYPE_PSEUDO &&
1675 argtype != RECORDOID)
1676 ereport(ERROR,
1677 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1678 errmsg("PL/Tcl functions cannot accept type %s",
1679 format_type_be(argtype))));
1680
1681 if (type_is_rowtype(argtype))
1682 {
1683 prodesc->arg_is_rowtype[i] = true;
1684 snprintf(buf, sizeof(buf), "__PLTcl_Tup_%d", i + 1);
1685 }
1686 else
1687 {
1688 prodesc->arg_is_rowtype[i] = false;
1689 fmgr_info_cxt(typeStruct->typoutput,
1690 &(prodesc->arg_out_func[i]),
1691 proc_cxt);
1692 snprintf(buf, sizeof(buf), "%d", i + 1);
1693 }
1694
1695 if (i > 0)
1696 strcat(proc_internal_args, " ");
1697 strcat(proc_internal_args, buf);
1698
1699 ReleaseSysCache(typeTup);
1700 }
1701 }
1702 else if (is_trigger)
1703 {
1704 /* trigger procedure has fixed args */
1705 strcpy(proc_internal_args,
1706 "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");
1707 }
1708 else if (is_event_trigger)
1709 {
1710 /* event trigger procedure has fixed args */
1711 strcpy(proc_internal_args, "TG_event TG_tag");
1712 }
1713
1714 /************************************************************
1715 * Create the tcl command to define the internal
1716 * procedure
1717 *
1718 * Leave this code as DString - performance is not critical here,
1719 * and we don't want to duplicate the knowledge of the Tcl quoting
1720 * rules that's embedded in Tcl_DStringAppendElement.
1721 ************************************************************/
1722 Tcl_DStringAppendElement(&proc_internal_def, "proc");
1723 Tcl_DStringAppendElement(&proc_internal_def, internal_proname);
1724 Tcl_DStringAppendElement(&proc_internal_def, proc_internal_args);
1725
1726 /************************************************************
1727 * prefix procedure body with
1728 * upvar #0 <internal_proname> GD
1729 * and with appropriate setting of arguments
1730 ************************************************************/
1731 Tcl_DStringAppend(&proc_internal_body, "upvar #0 ", -1);
1732 Tcl_DStringAppend(&proc_internal_body, internal_proname, -1);
1733 Tcl_DStringAppend(&proc_internal_body, " GD\n", -1);
1734 if (is_trigger)
1735 {
1736 Tcl_DStringAppend(&proc_internal_body,
1737 "array set NEW $__PLTcl_Tup_NEW\n", -1);
1738 Tcl_DStringAppend(&proc_internal_body,
1739 "array set OLD $__PLTcl_Tup_OLD\n", -1);
1740 Tcl_DStringAppend(&proc_internal_body,
1741 "set i 0\n"
1742 "set v 0\n"
1743 "foreach v $args {\n"
1744 " incr i\n"
1745 " set $i $v\n"
1746 "}\n"
1747 "unset i v\n\n", -1);
1748 }
1749 else if (is_event_trigger)
1750 {
1751 /* no argument support for event triggers */
1752 }
1753 else
1754 {
1755 for (i = 0; i < prodesc->nargs; i++)
1756 {
1757 if (prodesc->arg_is_rowtype[i])
1758 {
1759 snprintf(buf, sizeof(buf),
1760 "array set %d $__PLTcl_Tup_%d\n",
1761 i + 1, i + 1);
1762 Tcl_DStringAppend(&proc_internal_body, buf, -1);
1763 }
1764 }
1765 }
1766
1767 /************************************************************
1768 * Add user's function definition to proc body
1769 ************************************************************/
1770 prosrcdatum = SysCacheGetAttrNotNull(PROCOID, procTup,
1771 Anum_pg_proc_prosrc);
1772 proc_source = TextDatumGetCString(prosrcdatum);
1773 UTF_BEGIN;
1774 Tcl_DStringAppend(&proc_internal_body, UTF_E2U(proc_source), -1);
1775 UTF_END;
1776 pfree(proc_source);
1777 Tcl_DStringAppendElement(&proc_internal_def,
1778 Tcl_DStringValue(&proc_internal_body));
1779
1780 /************************************************************
1781 * Create the procedure in the interpreter
1782 ************************************************************/
1783 tcl_rc = Tcl_EvalEx(interp,
1784 Tcl_DStringValue(&proc_internal_def),
1785 Tcl_DStringLength(&proc_internal_def),
1786 TCL_EVAL_GLOBAL);
1787 if (tcl_rc != TCL_OK)
1788 ereport(ERROR,
1789 (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
1790 errmsg("could not create internal procedure \"%s\": %s",
1791 internal_proname,
1792 utf_u2e(Tcl_GetStringResult(interp)))));
1793 }
1794 PG_CATCH();
1795 {
1796 /*
1797 * If we failed anywhere above, clean up whatever got allocated. It
1798 * should all be in the proc_cxt, except for the DStrings.
1799 */
1800 if (proc_cxt)
1801 MemoryContextDelete(proc_cxt);
1802 Tcl_DStringFree(&proc_internal_def);
1803 Tcl_DStringFree(&proc_internal_name);
1804 Tcl_DStringFree(&proc_internal_body);
1805 PG_RE_THROW();
1806 }
1807 PG_END_TRY();
1808
1809 /*
1810 * Install the new proc description block in the hashtable, incrementing
1811 * its refcount (the hashtable link counts as a reference). Then, if
1812 * there was a previous definition of the function, decrement that one's
1813 * refcount, and delete it if no longer referenced. The order of
1814 * operations here is important: if something goes wrong during the
1815 * MemoryContextDelete, leaking some memory for the old definition is OK,
1816 * but we don't want to corrupt the live hashtable entry. (Likewise,
1817 * freeing the DStrings is pretty low priority if that happens.)
1818 */
1819 old_prodesc = proc_ptr->proc_ptr;
1820
1821 proc_ptr->proc_ptr = prodesc;
1822 prodesc->fn_refcount++;
1823
1824 if (old_prodesc != NULL)
1825 {
1826 Assert(old_prodesc->fn_refcount > 0);
1827 if (--old_prodesc->fn_refcount == 0)
1828 MemoryContextDelete(old_prodesc->fn_cxt);
1829 }
1830
1831 Tcl_DStringFree(&proc_internal_def);
1832 Tcl_DStringFree(&proc_internal_name);
1833 Tcl_DStringFree(&proc_internal_body);
1834
1835 ReleaseSysCache(procTup);
1836
1837 return prodesc;
1838}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, pltcl_proc_desc::arg_is_rowtype, pltcl_proc_desc::arg_out_func, Assert, buf, pltcl_proc_desc::domain_info, elog, ereport, errcode(), errmsg, ERROR, fb(), fmgr_info_cxt(), pltcl_proc_desc::fn_cxt, pltcl_proc_desc::fn_readonly, pltcl_proc_desc::fn_refcount, pltcl_proc_desc::fn_retisdomain, pltcl_proc_desc::fn_retisset, pltcl_proc_desc::fn_retistuple, pltcl_proc_desc::fn_tid, pltcl_proc_desc::fn_xmin, Form_pg_proc, Form_pg_type, format_procedure(), format_type_be(), FUNC_MAX_ARGS, GETSTRUCT(), getTypeIOParam(), GetUserId(), HASH_ENTER, hash_search(), HeapTupleHeaderGetRawXmin(), HeapTupleIsValid, i, pltcl_proc_desc::internal_proname, pltcl_interp_desc::interp, pltcl_proc_desc::interp_desc, InvalidOid, pltcl_proc_key::is_trigger, ItemPointerEquals(), pltcl_proc_desc::lanpltrusted, MemoryContextDelete(), MemoryContextSetIdentifier(), MemoryContextSwitchTo(), pltcl_proc_desc::nargs, ObjectIdGetDatum(), OidIsValid, palloc0(), palloc0_object, pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pltcl_fetch_interp(), pltcl_proc_htab, pltcl_proc_key::proc_id, pltcl_proc_ptr::proc_ptr, pstrdup(), ReleaseSysCache(), pltcl_proc_desc::result_in_func, pltcl_proc_desc::result_typid, pltcl_proc_desc::result_typioparam, SearchSysCache1(), snprintf, SysCacheGetAttrNotNull(), TextDatumGetCString, TopMemoryContext, type_is_rowtype(), pltcl_proc_key::user_id, pltcl_proc_desc::user_proname, UTF_BEGIN, UTF_E2U, UTF_END, and utf_u2e().

Referenced by pltcl_event_trigger_handler(), pltcl_func_handler(), and pltcl_trigger_handler().

◆ PG_FUNCTION_INFO_V1() [1/2]

PG_FUNCTION_INFO_V1 ( pltcl_call_handler  )

◆ PG_FUNCTION_INFO_V1() [2/2]

PG_FUNCTION_INFO_V1 ( pltclu_call_handler  )

◆ PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT ( .  name = "pltcl",
.  version = PG_VERSION 
)

◆ pltcl_AlertNotifier()

static void pltcl_AlertNotifier ( ClientData  clientData)
static

Definition at line 374 of file pltcl.c.

375{
376}

Referenced by _PG_init().

◆ pltcl_argisnull()

static int pltcl_argisnull ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2149 of file pltcl.c.

2151{
2152 int argno;
2153 FunctionCallInfo fcinfo = pltcl_current_call_state->fcinfo;
2154
2155 /************************************************************
2156 * Check call syntax
2157 ************************************************************/
2158 if (objc != 2)
2159 {
2160 Tcl_WrongNumArgs(interp, 1, objv, "argno");
2161 return TCL_ERROR;
2162 }
2163
2164 /************************************************************
2165 * Check that we're called as a normal function
2166 ************************************************************/
2167 if (fcinfo == NULL)
2168 {
2169 Tcl_SetObjResult(interp,
2170 Tcl_NewStringObj("argisnull cannot be used in triggers", -1));
2171 return TCL_ERROR;
2172 }
2173
2174 /************************************************************
2175 * Get the argument number
2176 ************************************************************/
2177 if (Tcl_GetIntFromObj(interp, objv[1], &argno) != TCL_OK)
2178 return TCL_ERROR;
2179
2180 /************************************************************
2181 * Check that the argno is valid
2182 ************************************************************/
2183 argno--;
2184 if (argno < 0 || argno >= fcinfo->nargs)
2185 {
2186 Tcl_SetObjResult(interp,
2187 Tcl_NewStringObj("argno out of range", -1));
2188 return TCL_ERROR;
2189 }
2190
2191 /************************************************************
2192 * Get the requested NULL state
2193 ************************************************************/
2194 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(PG_ARGISNULL(argno)));
2195 return TCL_OK;
2196}

References fb(), pltcl_call_state::fcinfo, FunctionCallInfoBaseData::nargs, PG_ARGISNULL, and pltcl_current_call_state.

Referenced by pltcl_init_interp().

◆ pltcl_build_tuple_argument()

static Tcl_Obj * pltcl_build_tuple_argument ( HeapTuple  tuple,
TupleDesc  tupdesc,
bool  include_generated 
)
static

Definition at line 3190 of file pltcl.c.

3191{
3192 Tcl_Obj *retobj = Tcl_NewObj();
3193 int i;
3194 char *outputstr;
3195 Datum attr;
3196 bool isnull;
3197 char *attname;
3198 Oid typoutput;
3199 bool typisvarlena;
3200
3201 for (i = 0; i < tupdesc->natts; i++)
3202 {
3203 Form_pg_attribute att = TupleDescAttr(tupdesc, i);
3204
3205 /* ignore dropped attributes */
3206 if (att->attisdropped)
3207 continue;
3208
3209 if (att->attgenerated)
3210 {
3211 /* don't include unless requested */
3212 if (!include_generated)
3213 continue;
3214 /* never include virtual columns */
3215 if (att->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
3216 continue;
3217 }
3218
3219 /************************************************************
3220 * Get the attribute name
3221 ************************************************************/
3222 attname = NameStr(att->attname);
3223
3224 /************************************************************
3225 * Get the attributes value
3226 ************************************************************/
3227 attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
3228
3229 /************************************************************
3230 * If there is a value, append the attribute name and the
3231 * value to the list
3232 *
3233 * Hmmm - Null attributes will cause functions to
3234 * crash if they don't expect them - need something
3235 * smarter here.
3236 ************************************************************/
3237 if (!isnull)
3238 {
3239 getTypeOutputInfo(att->atttypid,
3240 &typoutput, &typisvarlena);
3241 outputstr = OidOutputFunctionCall(typoutput, attr);
3242 UTF_BEGIN;
3243 Tcl_ListObjAppendElement(NULL, retobj,
3244 Tcl_NewStringObj(UTF_E2U(attname), -1));
3245 UTF_END;
3246 UTF_BEGIN;
3247 Tcl_ListObjAppendElement(NULL, retobj,
3248 Tcl_NewStringObj(UTF_E2U(outputstr), -1));
3249 UTF_END;
3250 pfree(outputstr);
3251 }
3252 }
3253
3254 return retobj;
3255}

References attname, fb(), getTypeOutputInfo(), heap_getattr(), i, NameStr, TupleDescData::natts, OidOutputFunctionCall(), pfree(), TupleDescAttr(), UTF_BEGIN, UTF_E2U, and UTF_END.

Referenced by pltcl_func_handler(), and pltcl_trigger_handler().

◆ pltcl_build_tuple_result()

static HeapTuple pltcl_build_tuple_result ( Tcl_Interp *  interp,
Tcl_Obj **  kvObjv,
int  kvObjc,
pltcl_call_state *  call_state 
)
static

Definition at line 3269 of file pltcl.c.

3271{
3272 HeapTuple tuple;
3273 TupleDesc tupdesc;
3274 AttInMetadata *attinmeta;
3275 char **values;
3276 int i;
3277
3278 if (call_state->ret_tupdesc)
3279 {
3280 tupdesc = call_state->ret_tupdesc;
3281 attinmeta = call_state->attinmeta;
3282 }
3283 else if (call_state->trigdata)
3284 {
3285 tupdesc = RelationGetDescr(call_state->trigdata->tg_relation);
3286 attinmeta = TupleDescGetAttInMetadata(tupdesc);
3287 }
3288 else
3289 {
3290 elog(ERROR, "PL/Tcl function does not return a tuple");
3291 tupdesc = NULL; /* keep compiler quiet */
3292 attinmeta = NULL;
3293 }
3294
3295 values = (char **) palloc0(tupdesc->natts * sizeof(char *));
3296
3297 if (kvObjc % 2 != 0)
3298 ereport(ERROR,
3299 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3300 errmsg("column name/value list must have even number of elements")));
3301
3302 for (i = 0; i < kvObjc; i += 2)
3303 {
3304 char *fieldName = utf_u2e(Tcl_GetString(kvObjv[i]));
3305 int attn = SPI_fnumber(tupdesc, fieldName);
3306
3307 /*
3308 * We silently ignore ".tupno", if it's present but doesn't match any
3309 * actual output column. This allows direct use of a row returned by
3310 * pltcl_set_tuple_values().
3311 */
3312 if (attn == SPI_ERROR_NOATTRIBUTE)
3313 {
3314 if (strcmp(fieldName, ".tupno") == 0)
3315 continue;
3316 ereport(ERROR,
3317 (errcode(ERRCODE_UNDEFINED_COLUMN),
3318 errmsg("column name/value list contains nonexistent column name \"%s\"",
3319 fieldName)));
3320 }
3321
3322 if (attn <= 0)
3323 ereport(ERROR,
3324 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3325 errmsg("cannot set system attribute \"%s\"",
3326 fieldName)));
3327
3328 if (TupleDescAttr(tupdesc, attn - 1)->attgenerated)
3329 ereport(ERROR,
3330 (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
3331 errmsg("cannot set generated column \"%s\"",
3332 fieldName)));
3333
3334 values[attn - 1] = utf_u2e(Tcl_GetString(kvObjv[i + 1]));
3335 }
3336
3337 tuple = BuildTupleFromCStrings(attinmeta, values);
3338
3339 /* if result type is domain-over-composite, check domain constraints */
3340 if (call_state->prodesc->fn_retisdomain)
3341 domain_check(HeapTupleGetDatum(tuple), false,
3342 call_state->prodesc->result_typid,
3343 &call_state->prodesc->domain_info,
3344 call_state->prodesc->fn_cxt);
3345
3346 return tuple;
3347}

References BuildTupleFromCStrings(), domain_check(), elog, ereport, errcode(), errmsg, ERROR, fb(), HeapTupleGetDatum(), i, TupleDescData::natts, palloc0(), RelationGetDescr, SPI_ERROR_NOATTRIBUTE, SPI_fnumber(), TupleDescAttr(), TupleDescGetAttInMetadata(), utf_u2e(), and values.

Referenced by pltcl_func_handler(), pltcl_returnnext(), and pltcl_trigger_handler().

◆ pltcl_call_handler()

Datum pltcl_call_handler ( PG_FUNCTION_ARGS  )

Definition at line 706 of file pltcl.c.

707{
708 return pltcl_handler(fcinfo, true);
709}

References pltcl_handler().

◆ pltcl_commit()

static int pltcl_commit ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 3025 of file pltcl.c.

3027{
3028 MemoryContext oldcontext = CurrentMemoryContext;
3029
3030 PG_TRY();
3031 {
3032 SPI_commit();
3033 }
3034 PG_CATCH();
3035 {
3036 ErrorData *edata;
3037
3038 /* Save error info */
3039 MemoryContextSwitchTo(oldcontext);
3040 edata = CopyErrorData();
3041 FlushErrorState();
3042
3043 /* Pass the error data to Tcl */
3044 pltcl_construct_errorCode(interp, edata);
3045 UTF_BEGIN;
3046 Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
3047 UTF_END;
3048 FreeErrorData(edata);
3049
3050 return TCL_ERROR;
3051 }
3052 PG_END_TRY();
3053
3054 return TCL_OK;
3055}

References CopyErrorData(), CurrentMemoryContext, fb(), FlushErrorState(), FreeErrorData(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_TRY, pltcl_construct_errorCode(), SPI_commit(), UTF_BEGIN, UTF_E2U, and UTF_END.

Referenced by pltcl_init_interp().

◆ pltcl_construct_errorCode()

static void pltcl_construct_errorCode ( Tcl_Interp *  interp,
ErrorData *  edata 
)
static

Definition at line 1932 of file pltcl.c.

1933{
1934 Tcl_Obj *obj = Tcl_NewObj();
1935
1936 Tcl_ListObjAppendElement(interp, obj,
1937 Tcl_NewStringObj("POSTGRES", -1));
1938 Tcl_ListObjAppendElement(interp, obj,
1939 Tcl_NewStringObj(PG_VERSION, -1));
1940 Tcl_ListObjAppendElement(interp, obj,
1941 Tcl_NewStringObj("SQLSTATE", -1));
1942 Tcl_ListObjAppendElement(interp, obj,
1943 Tcl_NewStringObj(unpack_sql_state(edata->sqlerrcode), -1));
1944 Tcl_ListObjAppendElement(interp, obj,
1945 Tcl_NewStringObj("condition", -1));
1946 Tcl_ListObjAppendElement(interp, obj,
1947 Tcl_NewStringObj(pltcl_get_condition_name(edata->sqlerrcode), -1));
1948 Tcl_ListObjAppendElement(interp, obj,
1949 Tcl_NewStringObj("message", -1));
1950 UTF_BEGIN;
1951 Tcl_ListObjAppendElement(interp, obj,
1952 Tcl_NewStringObj(UTF_E2U(edata->message), -1));
1953 UTF_END;
1954 if (edata->detail)
1955 {
1956 Tcl_ListObjAppendElement(interp, obj,
1957 Tcl_NewStringObj("detail", -1));
1958 UTF_BEGIN;
1959 Tcl_ListObjAppendElement(interp, obj,
1960 Tcl_NewStringObj(UTF_E2U(edata->detail), -1));
1961 UTF_END;
1962 }
1963 if (edata->hint)
1964 {
1965 Tcl_ListObjAppendElement(interp, obj,
1966 Tcl_NewStringObj("hint", -1));
1967 UTF_BEGIN;
1968 Tcl_ListObjAppendElement(interp, obj,
1969 Tcl_NewStringObj(UTF_E2U(edata->hint), -1));
1970 UTF_END;
1971 }
1972 if (edata->context)
1973 {
1974 Tcl_ListObjAppendElement(interp, obj,
1975 Tcl_NewStringObj("context", -1));
1976 UTF_BEGIN;
1977 Tcl_ListObjAppendElement(interp, obj,
1978 Tcl_NewStringObj(UTF_E2U(edata->context), -1));
1979 UTF_END;
1980 }
1981 if (edata->schema_name)
1982 {
1983 Tcl_ListObjAppendElement(interp, obj,
1984 Tcl_NewStringObj("schema", -1));
1985 UTF_BEGIN;
1986 Tcl_ListObjAppendElement(interp, obj,
1987 Tcl_NewStringObj(UTF_E2U(edata->schema_name), -1));
1988 UTF_END;
1989 }
1990 if (edata->table_name)
1991 {
1992 Tcl_ListObjAppendElement(interp, obj,
1993 Tcl_NewStringObj("table", -1));
1994 UTF_BEGIN;
1995 Tcl_ListObjAppendElement(interp, obj,
1996 Tcl_NewStringObj(UTF_E2U(edata->table_name), -1));
1997 UTF_END;
1998 }
1999 if (edata->column_name)
2000 {
2001 Tcl_ListObjAppendElement(interp, obj,
2002 Tcl_NewStringObj("column", -1));
2003 UTF_BEGIN;
2004 Tcl_ListObjAppendElement(interp, obj,
2005 Tcl_NewStringObj(UTF_E2U(edata->column_name), -1));
2006 UTF_END;
2007 }
2008 if (edata->datatype_name)
2009 {
2010 Tcl_ListObjAppendElement(interp, obj,
2011 Tcl_NewStringObj("datatype", -1));
2012 UTF_BEGIN;
2013 Tcl_ListObjAppendElement(interp, obj,
2014 Tcl_NewStringObj(UTF_E2U(edata->datatype_name), -1));
2015 UTF_END;
2016 }
2017 if (edata->constraint_name)
2018 {
2019 Tcl_ListObjAppendElement(interp, obj,
2020 Tcl_NewStringObj("constraint", -1));
2021 UTF_BEGIN;
2022 Tcl_ListObjAppendElement(interp, obj,
2023 Tcl_NewStringObj(UTF_E2U(edata->constraint_name), -1));
2024 UTF_END;
2025 }
2026 /* cursorpos is never interesting here; report internal query/pos */
2027 if (edata->internalquery)
2028 {
2029 Tcl_ListObjAppendElement(interp, obj,
2030 Tcl_NewStringObj("statement", -1));
2031 UTF_BEGIN;
2032 Tcl_ListObjAppendElement(interp, obj,
2033 Tcl_NewStringObj(UTF_E2U(edata->internalquery), -1));
2034 UTF_END;
2035 }
2036 if (edata->internalpos > 0)
2037 {
2038 Tcl_ListObjAppendElement(interp, obj,
2039 Tcl_NewStringObj("cursor_position", -1));
2040 Tcl_ListObjAppendElement(interp, obj,
2041 Tcl_NewIntObj(edata->internalpos));
2042 }
2043 if (edata->filename)
2044 {
2045 Tcl_ListObjAppendElement(interp, obj,
2046 Tcl_NewStringObj("filename", -1));
2047 UTF_BEGIN;
2048 Tcl_ListObjAppendElement(interp, obj,
2049 Tcl_NewStringObj(UTF_E2U(edata->filename), -1));
2050 UTF_END;
2051 }
2052 if (edata->lineno > 0)
2053 {
2054 Tcl_ListObjAppendElement(interp, obj,
2055 Tcl_NewStringObj("lineno", -1));
2056 Tcl_ListObjAppendElement(interp, obj,
2057 Tcl_NewIntObj(edata->lineno));
2058 }
2059 if (edata->funcname)
2060 {
2061 Tcl_ListObjAppendElement(interp, obj,
2062 Tcl_NewStringObj("funcname", -1));
2063 UTF_BEGIN;
2064 Tcl_ListObjAppendElement(interp, obj,
2065 Tcl_NewStringObj(UTF_E2U(edata->funcname), -1));
2066 UTF_END;
2067 }
2068
2069 Tcl_SetObjErrorCode(interp, obj);
2070}

References fb(), pltcl_get_condition_name(), unpack_sql_state(), UTF_BEGIN, UTF_E2U, and UTF_END.

Referenced by pltcl_commit(), pltcl_elog(), pltcl_rollback(), and pltcl_subtrans_abort().

◆ pltcl_CreateFileHandler()

static void pltcl_CreateFileHandler ( int  fd,
int  mask,
Tcl_FileProc *  proc,
ClientData  clientData 
)
static

Definition at line 379 of file pltcl.c.

381{
382}

Referenced by _PG_init().

◆ pltcl_DeleteFileHandler()

static void pltcl_DeleteFileHandler ( int  fd)
static

Definition at line 385 of file pltcl.c.

386{
387}

Referenced by _PG_init().

◆ pltcl_elog()

static int pltcl_elog ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 1845 of file pltcl.c.

1847{
1848 volatile int level;
1849 MemoryContext oldcontext;
1850 int priIndex;
1851
1852 static const char *logpriorities[] = {
1853 "DEBUG", "LOG", "INFO", "NOTICE",
1854 "WARNING", "ERROR", "FATAL", (const char *) NULL
1855 };
1856
1857 static const int loglevels[] = {
1858 DEBUG2, LOG, INFO, NOTICE,
1859 WARNING, ERROR, FATAL
1860 };
1861
1862 if (objc != 3)
1863 {
1864 Tcl_WrongNumArgs(interp, 1, objv, "level msg");
1865 return TCL_ERROR;
1866 }
1867
1868 if (Tcl_GetIndexFromObj(interp, objv[1], logpriorities, "priority",
1869 TCL_EXACT, &priIndex) != TCL_OK)
1870 return TCL_ERROR;
1871
1872 level = loglevels[priIndex];
1873
1874 if (level == ERROR)
1875 {
1876 /*
1877 * We just pass the error back to Tcl. If it's not caught, it'll
1878 * eventually get converted to a PG error when we reach the call
1879 * handler.
1880 */
1881 Tcl_SetObjResult(interp, objv[2]);
1882 return TCL_ERROR;
1883 }
1884
1885 /*
1886 * For non-error messages, just pass 'em to ereport(). We do not expect
1887 * that this will fail, but just on the off chance it does, report the
1888 * error back to Tcl. Note we are assuming that ereport() can't have any
1889 * internal failures that are so bad as to require a transaction abort.
1890 *
1891 * This path is also used for FATAL errors, which aren't going to come
1892 * back to us at all.
1893 */
1894 oldcontext = CurrentMemoryContext;
1895 PG_TRY();
1896 {
1897 UTF_BEGIN;
1898 ereport(level,
1899 (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
1900 errmsg("%s", UTF_U2E(Tcl_GetString(objv[2])))));
1901 UTF_END;
1902 }
1903 PG_CATCH();
1904 {
1905 ErrorData *edata;
1906
1907 /* Must reset elog.c's state */
1908 MemoryContextSwitchTo(oldcontext);
1909 edata = CopyErrorData();
1910 FlushErrorState();
1911
1912 /* Pass the error data to Tcl */
1913 pltcl_construct_errorCode(interp, edata);
1914 UTF_BEGIN;
1915 Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
1916 UTF_END;
1917 FreeErrorData(edata);
1918
1919 return TCL_ERROR;
1920 }
1921 PG_END_TRY();
1922
1923 return TCL_OK;
1924}

References CopyErrorData(), CurrentMemoryContext, DEBUG2, ereport, errcode(), errmsg, ERROR, FATAL, fb(), FlushErrorState(), FreeErrorData(), INFO, LOG, MemoryContextSwitchTo(), NOTICE, PG_CATCH, PG_END_TRY, PG_TRY, pltcl_construct_errorCode(), UTF_BEGIN, UTF_E2U, UTF_END, UTF_U2E, and WARNING.

Referenced by pltcl_init_interp().

◆ pltcl_event_trigger_handler()

static void pltcl_event_trigger_handler ( PG_FUNCTION_ARGS  ,
pltcl_call_state *  call_state,
bool  pltrusted 
)
static

Definition at line 1320 of file pltcl.c.

1322{
1323 pltcl_proc_desc *prodesc;
1324 Tcl_Interp *volatile interp;
1325 EventTriggerData *tdata = (EventTriggerData *) fcinfo->context;
1326 Tcl_Obj *tcl_cmd;
1327 int tcl_rc;
1328
1329 /* Connect to SPI manager */
1330 SPI_connect();
1331
1332 /* Find or compile the function */
1333 prodesc = compile_pltcl_function(fcinfo->flinfo->fn_oid,
1334 InvalidOid, true, pltrusted);
1335
1336 call_state->prodesc = prodesc;
1337 prodesc->fn_refcount++;
1338
1339 interp = prodesc->interp_desc->interp;
1340
1341 /* Create the tcl command and call the internal proc */
1342 tcl_cmd = Tcl_NewObj();
1343 Tcl_IncrRefCount(tcl_cmd);
1344 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1345 Tcl_NewStringObj(prodesc->internal_proname, -1));
1346 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1347 Tcl_NewStringObj(utf_e2u(tdata->event), -1));
1348 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1349 Tcl_NewStringObj(utf_e2u(GetCommandTagName(tdata->tag)),
1350 -1));
1351
1352 tcl_rc = Tcl_EvalObjEx(interp, tcl_cmd, (TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL));
1353
1354 /* Release refcount to free tcl_cmd (and all subsidiary objects) */
1355 Tcl_DecrRefCount(tcl_cmd);
1356
1357 /* Check for errors reported by Tcl. */
1358 if (tcl_rc != TCL_OK)
1359 throw_tcl_error(interp, prodesc->user_proname);
1360
1361 if (SPI_finish() != SPI_OK_FINISH)
1362 elog(ERROR, "SPI_finish() failed");
1363}

References compile_pltcl_function(), elog, ERROR, fb(), pltcl_proc_desc::fn_refcount, GetCommandTagName(), pltcl_proc_desc::internal_proname, pltcl_interp_desc::interp, pltcl_proc_desc::interp_desc, InvalidOid, SPI_connect(), SPI_finish(), SPI_OK_FINISH, throw_tcl_error(), pltcl_proc_desc::user_proname, and utf_e2u().

Referenced by pltcl_handler().

◆ pltcl_fetch_interp()

static pltcl_interp_desc * pltcl_fetch_interp ( Oid  prolang,
bool  pltrusted 
)
static

Definition at line 569 of file pltcl.c.

570{
571 Oid user_id;
572 pltcl_interp_desc *interp_desc;
573 bool found;
574
575 /* Find or create the interpreter hashtable entry for this userid */
576 if (pltrusted)
577 user_id = GetUserId();
578 else
579 user_id = InvalidOid;
580
581 interp_desc = hash_search(pltcl_interp_htab, &user_id,
582 HASH_ENTER,
583 &found);
584 if (!found)
585 interp_desc->interp = NULL;
586
587 /* If we haven't yet successfully made an interpreter, try to do that */
588 if (!interp_desc->interp)
589 pltcl_init_interp(interp_desc, prolang, pltrusted);
590
591 return interp_desc;
592}

References fb(), GetUserId(), HASH_ENTER, hash_search(), pltcl_interp_desc::interp, InvalidOid, pltcl_init_interp(), and pltcl_interp_htab.

Referenced by compile_pltcl_function().

◆ pltcl_FinalizeNotifier()

static void pltcl_FinalizeNotifier ( ClientData  clientData)
static

Definition at line 364 of file pltcl.c.

365{
366}

Referenced by _PG_init().

◆ pltcl_func_handler()

static Datum pltcl_func_handler ( PG_FUNCTION_ARGS  ,
pltcl_call_state *  call_state,
bool  pltrusted 
)
static

Definition at line 803 of file pltcl.c.

805{
806 bool nonatomic;
807 pltcl_proc_desc *prodesc;
808 Tcl_Interp *volatile interp;
809 Tcl_Obj *tcl_cmd;
810 int i;
811 int tcl_rc;
812 Datum retval;
813
814 nonatomic = fcinfo->context &&
815 IsA(fcinfo->context, CallContext) &&
816 !castNode(CallContext, fcinfo->context)->atomic;
817
818 /* Connect to SPI manager */
819 SPI_connect_ext(nonatomic ? SPI_OPT_NONATOMIC : 0);
820
821 /* Find or compile the function */
822 prodesc = compile_pltcl_function(fcinfo->flinfo->fn_oid, InvalidOid,
823 false, pltrusted);
824
825 call_state->prodesc = prodesc;
826 prodesc->fn_refcount++;
827
828 interp = prodesc->interp_desc->interp;
829
830 /*
831 * If we're a SRF, check caller can handle materialize mode, and save
832 * relevant info into call_state. We must ensure that the returned
833 * tuplestore is owned by the caller's context, even if we first create it
834 * inside a subtransaction.
835 */
836 if (prodesc->fn_retisset)
837 {
838 ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
839
840 if (!rsi || !IsA(rsi, ReturnSetInfo))
841 ereport(ERROR,
842 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
843 errmsg("set-valued function called in context that cannot accept a set")));
844
845 if (!(rsi->allowedModes & SFRM_Materialize))
846 ereport(ERROR,
847 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
848 errmsg("materialize mode required, but it is not allowed in this context")));
849
850 call_state->rsi = rsi;
851 call_state->tuple_store_cxt = rsi->econtext->ecxt_per_query_memory;
852 call_state->tuple_store_owner = CurrentResourceOwner;
853 }
854
855 /************************************************************
856 * Create the tcl command to call the internal
857 * proc in the Tcl interpreter
858 ************************************************************/
859 tcl_cmd = Tcl_NewObj();
860 Tcl_ListObjAppendElement(NULL, tcl_cmd,
861 Tcl_NewStringObj(prodesc->internal_proname, -1));
862
863 /* We hold a refcount on tcl_cmd just to be sure it stays around */
864 Tcl_IncrRefCount(tcl_cmd);
865
866 /************************************************************
867 * Add all call arguments to the command
868 ************************************************************/
869 PG_TRY();
870 {
871 for (i = 0; i < prodesc->nargs; i++)
872 {
873 if (prodesc->arg_is_rowtype[i])
874 {
875 /**************************************************
876 * For tuple values, add a list for 'array set ...'
877 **************************************************/
878 if (fcinfo->args[i].isnull)
879 Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
880 else
881 {
882 HeapTupleHeader td;
883 Oid tupType;
884 int32 tupTypmod;
885 TupleDesc tupdesc;
886 HeapTupleData tmptup;
887 Tcl_Obj *list_tmp;
888
889 td = DatumGetHeapTupleHeader(fcinfo->args[i].value);
890 /* Extract rowtype info and find a tupdesc */
891 tupType = HeapTupleHeaderGetTypeId(td);
892 tupTypmod = HeapTupleHeaderGetTypMod(td);
893 tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
894 /* Build a temporary HeapTuple control structure */
895 tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
896 tmptup.t_data = td;
897
898 list_tmp = pltcl_build_tuple_argument(&tmptup, tupdesc, true);
899 Tcl_ListObjAppendElement(NULL, tcl_cmd, list_tmp);
900
901 ReleaseTupleDesc(tupdesc);
902 }
903 }
904 else
905 {
906 /**************************************************
907 * Single values are added as string element
908 * of their external representation
909 **************************************************/
910 if (fcinfo->args[i].isnull)
911 Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
912 else
913 {
914 char *tmp;
915
916 tmp = OutputFunctionCall(&prodesc->arg_out_func[i],
917 fcinfo->args[i].value);
918 UTF_BEGIN;
919 Tcl_ListObjAppendElement(NULL, tcl_cmd,
920 Tcl_NewStringObj(UTF_E2U(tmp), -1));
921 UTF_END;
922 pfree(tmp);
923 }
924 }
925 }
926 }
927 PG_CATCH();
928 {
929 /* Release refcount to free tcl_cmd */
930 Tcl_DecrRefCount(tcl_cmd);
931 PG_RE_THROW();
932 }
933 PG_END_TRY();
934
935 /************************************************************
936 * Call the Tcl function
937 *
938 * We assume no PG error can be thrown directly from this call.
939 ************************************************************/
940 tcl_rc = Tcl_EvalObjEx(interp, tcl_cmd, (TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL));
941
942 /* Release refcount to free tcl_cmd (and all subsidiary objects) */
943 Tcl_DecrRefCount(tcl_cmd);
944
945 /************************************************************
946 * Check for errors reported by Tcl.
947 ************************************************************/
948 if (tcl_rc != TCL_OK)
949 throw_tcl_error(interp, prodesc->user_proname);
950
951 /************************************************************
952 * Disconnect from SPI manager and then create the return
953 * value datum (if the input function does a palloc for it
954 * this must not be allocated in the SPI memory context
955 * because SPI_finish would free it). But don't try to call
956 * the result_in_func if we've been told to return a NULL;
957 * the Tcl result may not be a valid value of the result type
958 * in that case.
959 ************************************************************/
960 if (SPI_finish() != SPI_OK_FINISH)
961 elog(ERROR, "SPI_finish() failed");
962
963 if (prodesc->fn_retisset)
964 {
965 ReturnSetInfo *rsi = call_state->rsi;
966
967 /* We already checked this is OK */
968 rsi->returnMode = SFRM_Materialize;
969
970 /* If we produced any tuples, send back the result */
971 if (call_state->tuple_store)
972 {
973 rsi->setResult = call_state->tuple_store;
974 if (call_state->ret_tupdesc)
975 {
976 MemoryContext oldcxt;
977
978 oldcxt = MemoryContextSwitchTo(call_state->tuple_store_cxt);
979 rsi->setDesc = CreateTupleDescCopy(call_state->ret_tupdesc);
980 MemoryContextSwitchTo(oldcxt);
981 }
982 }
983 retval = (Datum) 0;
984 fcinfo->isnull = true;
985 }
986 else if (fcinfo->isnull)
987 {
988 retval = InputFunctionCall(&prodesc->result_in_func,
989 NULL,
990 prodesc->result_typioparam,
991 -1);
992 }
993 else if (prodesc->fn_retistuple)
994 {
995 TupleDesc td;
996 HeapTuple tup;
997 Tcl_Obj *resultObj;
998 Tcl_Obj **resultObjv;
999 Tcl_Size resultObjc;
1000
1001 /*
1002 * Set up data about result type. XXX it's tempting to consider
1003 * caching this in the prodesc, in the common case where the rowtype
1004 * is determined by the function not the calling query. But we'd have
1005 * to be able to deal with ADD/DROP/ALTER COLUMN events when the
1006 * result type is a named composite type, so it's not exactly trivial.
1007 * Maybe worth improving someday.
1008 */
1009 switch (get_call_result_type(fcinfo, NULL, &td))
1010 {
1011 case TYPEFUNC_COMPOSITE:
1012 /* success */
1013 break;
1014 case TYPEFUNC_COMPOSITE_DOMAIN:
1015 Assert(prodesc->fn_retisdomain);
1016 break;
1017 case TYPEFUNC_RECORD:
1018 /* failed to determine actual type of RECORD */
1019 ereport(ERROR,
1020 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1021 errmsg("function returning record called in context "
1022 "that cannot accept type record")));
1023 break;
1024 default:
1025 /* result type isn't composite? */
1026 elog(ERROR, "return type must be a row type");
1027 break;
1028 }
1029
1030 Assert(!call_state->ret_tupdesc);
1031 Assert(!call_state->attinmeta);
1032 call_state->ret_tupdesc = td;
1033 call_state->attinmeta = TupleDescGetAttInMetadata(td);
1034
1035 /* Convert function result to tuple */
1036 resultObj = Tcl_GetObjResult(interp);
1037 if (Tcl_ListObjGetElements(interp, resultObj, &resultObjc, &resultObjv) == TCL_ERROR)
1038 ereport(ERROR,
1039 (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
1040 errmsg("could not parse function return value: %s",
1041 utf_u2e(Tcl_GetStringResult(interp)))));
1042
1043 tup = pltcl_build_tuple_result(interp, resultObjv, resultObjc,
1044 call_state);
1045 retval = HeapTupleGetDatum(tup);
1046 }
1047 else
1048 retval = InputFunctionCall(&prodesc->result_in_func,
1049 utf_u2e(Tcl_GetStringResult(interp)),
1050 prodesc->result_typioparam,
1051 -1);
1052
1053 return retval;
1054}

References ReturnSetInfo::allowedModes, pltcl_proc_desc::arg_is_rowtype, pltcl_proc_desc::arg_out_func, Assert, castNode, compile_pltcl_function(), CreateTupleDescCopy(), CurrentResourceOwner, DatumGetHeapTupleHeader, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, elog, ereport, errcode(), errmsg, ERROR, fb(), pltcl_proc_desc::fn_refcount, pltcl_proc_desc::fn_retisdomain, pltcl_proc_desc::fn_retisset, pltcl_proc_desc::fn_retistuple, get_call_result_type(), HeapTupleGetDatum(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), i, InputFunctionCall(), pltcl_proc_desc::internal_proname, pltcl_interp_desc::interp, pltcl_proc_desc::interp_desc, InvalidOid, IsA, lookup_rowtype_tupdesc(), MemoryContextSwitchTo(), pltcl_proc_desc::nargs, OutputFunctionCall(), pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pltcl_build_tuple_argument(), pltcl_build_tuple_result(), ReleaseTupleDesc, pltcl_proc_desc::result_in_func, pltcl_proc_desc::result_typioparam, ReturnSetInfo::returnMode, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SPI_connect_ext(), SPI_finish(), SPI_OK_FINISH, SPI_OPT_NONATOMIC, throw_tcl_error(), TupleDescGetAttInMetadata(), TYPEFUNC_COMPOSITE, TYPEFUNC_COMPOSITE_DOMAIN, TYPEFUNC_RECORD, pltcl_proc_desc::user_proname, UTF_BEGIN, UTF_E2U, UTF_END, and utf_u2e().

Referenced by pltcl_handler().

◆ pltcl_get_condition_name()

static const char * pltcl_get_condition_name ( int  sqlstate)
static

Definition at line 2077 of file pltcl.c.

2078{
2079 int i;
2080
2081 for (i = 0; exception_name_map[i].label != NULL; i++)
2082 {
2083 if (exception_name_map[i].sqlerrstate == sqlstate)
2084 return exception_name_map[i].label;
2085 }
2086 return "unrecognized_sqlstate";
2087}

References exception_name_map, fb(), i, and TclExceptionNameMap::label.

Referenced by pltcl_construct_errorCode().

◆ pltcl_handler()

static Datum pltcl_handler ( PG_FUNCTION_ARGS  ,
bool  pltrusted 
)
static

Definition at line 729 of file pltcl.c.

730{
731 Datum retval = (Datum) 0;
732 pltcl_call_state current_call_state;
733 pltcl_call_state *save_call_state;
734
735 /*
736 * Initialize current_call_state to nulls/zeroes; in particular, set its
737 * prodesc pointer to null. Anything that sets it non-null should
738 * increase the prodesc's fn_refcount at the same time. We'll decrease
739 * the refcount, and then delete the prodesc if it's no longer referenced,
740 * on the way out of this function. This ensures that prodescs live as
741 * long as needed even if somebody replaces the originating pg_proc row
742 * while they're executing.
743 */
744 memset(&current_call_state, 0, sizeof(current_call_state));
745
746 /*
747 * Ensure that static pointer is saved/restored properly
748 */
749 save_call_state = pltcl_current_call_state;
750 pltcl_current_call_state = &current_call_state;
751
752 PG_TRY();
753 {
754 /*
755 * Determine if called as function or trigger and call appropriate
756 * subhandler
757 */
758 if (CALLED_AS_TRIGGER(fcinfo))
759 {
760 /* invoke the trigger handler */
761 retval = PointerGetDatum(pltcl_trigger_handler(fcinfo,
762 &current_call_state,
763 pltrusted));
764 }
765 else if (CALLED_AS_EVENT_TRIGGER(fcinfo))
766 {
767 /* invoke the event trigger handler */
768 pltcl_event_trigger_handler(fcinfo, &current_call_state, pltrusted);
769 retval = (Datum) 0;
770 }
771 else
772 {
773 /* invoke the regular function handler */
774 current_call_state.fcinfo = fcinfo;
775 retval = pltcl_func_handler(fcinfo, &current_call_state, pltrusted);
776 }
777 }
778 PG_FINALLY();
779 {
780 /* Restore static pointer, then clean up the prodesc refcount if any */
781 /*
782 * (We're being paranoid in case an error is thrown in context
783 * deletion)
784 */
785 pltcl_current_call_state = save_call_state;
786 if (current_call_state.prodesc != NULL)
787 {
788 Assert(current_call_state.prodesc->fn_refcount > 0);
789 if (--current_call_state.prodesc->fn_refcount == 0)
790 MemoryContextDelete(current_call_state.prodesc->fn_cxt);
791 }
792 }
793 PG_END_TRY();
794
795 return retval;
796}

References Assert, CALLED_AS_EVENT_TRIGGER, CALLED_AS_TRIGGER, fb(), MemoryContextDelete(), PG_END_TRY, PG_FINALLY, PG_TRY, pltcl_current_call_state, pltcl_event_trigger_handler(), pltcl_func_handler(), pltcl_trigger_handler(), and PointerGetDatum().

Referenced by pltcl_call_handler(), and pltclu_call_handler().

◆ pltcl_init_interp()

static void pltcl_init_interp ( pltcl_interp_desc *  interp_desc,
Oid  prolang,
bool  pltrusted 
)
static

Definition at line 496 of file pltcl.c.

497{
498 Tcl_Interp *interp;
499 char interpname[32];
500
501 /************************************************************
502 * Create the Tcl interpreter subsidiary to pltcl_hold_interp.
503 * Note: Tcl automatically does Tcl_Init in the untrusted case,
504 * and it's not wanted in the trusted case.
505 ************************************************************/
506 snprintf(interpname, sizeof(interpname), "subsidiary_%u", interp_desc->user_id);
507 if ((interp = Tcl_CreateSlave(pltcl_hold_interp, interpname,
508 pltrusted ? 1 : 0)) == NULL)
509 elog(ERROR, "could not create subsidiary Tcl interpreter");
510
511 /************************************************************
512 * Initialize the query hash table associated with interpreter
513 ************************************************************/
514 Tcl_InitHashTable(&interp_desc->query_hash, TCL_STRING_KEYS);
515
516 /************************************************************
517 * Install the commands for SPI support in the interpreter
518 ************************************************************/
519 Tcl_CreateObjCommand(interp, "elog",
520 pltcl_elog, NULL, NULL);
521 Tcl_CreateObjCommand(interp, "quote",
522 pltcl_quote, NULL, NULL);
523 Tcl_CreateObjCommand(interp, "argisnull",
524 pltcl_argisnull, NULL, NULL);
525 Tcl_CreateObjCommand(interp, "return_null",
526 pltcl_returnnull, NULL, NULL);
527 Tcl_CreateObjCommand(interp, "return_next",
528 pltcl_returnnext, NULL, NULL);
529 Tcl_CreateObjCommand(interp, "spi_exec",
530 pltcl_SPI_execute, NULL, NULL);
531 Tcl_CreateObjCommand(interp, "spi_prepare",
532 pltcl_SPI_prepare, NULL, NULL);
533 Tcl_CreateObjCommand(interp, "spi_execp",
534 pltcl_SPI_execute_plan, NULL, NULL);
535 Tcl_CreateObjCommand(interp, "subtransaction",
536 pltcl_subtransaction, NULL, NULL);
537 Tcl_CreateObjCommand(interp, "commit",
538 pltcl_commit, NULL, NULL);
539 Tcl_CreateObjCommand(interp, "rollback",
540 pltcl_rollback, NULL, NULL);
541
542 /************************************************************
543 * Call the appropriate start_proc, if there is one.
544 *
545 * We must set interp_desc->interp before the call, else the start_proc
546 * won't find the interpreter it's supposed to use. But, if the
547 * start_proc fails, we want to abandon use of the interpreter.
548 ************************************************************/
549 PG_TRY();
550 {
551 interp_desc->interp = interp;
552 call_pltcl_start_proc(prolang, pltrusted);
553 }
554 PG_CATCH();
555 {
556 interp_desc->interp = NULL;
557 Tcl_DeleteInterp(interp);
558 PG_RE_THROW();
559 }
560 PG_END_TRY();
561}

References call_pltcl_start_proc(), elog, ERROR, fb(), pltcl_interp_desc::interp, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pltcl_argisnull(), pltcl_commit(), pltcl_elog(), pltcl_hold_interp, pltcl_quote(), pltcl_returnnext(), pltcl_returnnull(), pltcl_rollback(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), pltcl_SPI_prepare(), pltcl_subtransaction(), pltcl_interp_desc::query_hash, snprintf, and pltcl_interp_desc::user_id.

Referenced by pltcl_fetch_interp().

◆ pltcl_init_tuple_store()

static void pltcl_init_tuple_store ( pltcl_call_state *  call_state)
static

Definition at line 3353 of file pltcl.c.

3354{
3355 ReturnSetInfo *rsi = call_state->rsi;
3356 MemoryContext oldcxt;
3357 ResourceOwner oldowner;
3358
3359 /* Should be in a SRF */
3360 Assert(rsi);
3361 /* Should be first time through */
3362 Assert(!call_state->tuple_store);
3363 Assert(!call_state->attinmeta);
3364
3365 /* We expect caller to provide an appropriate result tupdesc */
3366 Assert(rsi->expectedDesc);
3367 call_state->ret_tupdesc = rsi->expectedDesc;
3368
3369 /*
3370 * Switch to the right memory context and resource owner for storing the
3371 * tuplestore. If we're within a subtransaction opened for an exception
3372 * block, for example, we must still create the tuplestore in the resource
3373 * owner that was active when this function was entered, and not in the
3374 * subtransaction's resource owner.
3375 */
3376 oldcxt = MemoryContextSwitchTo(call_state->tuple_store_cxt);
3377 oldowner = CurrentResourceOwner;
3378 CurrentResourceOwner = call_state->tuple_store_owner;
3379
3380 call_state->tuple_store =
3381 tuplestore_begin_heap(rsi->allowedModes & SFRM_Materialize_Random,
3382 false, work_mem);
3383
3384 /* Build attinmeta in this context, too */
3385 call_state->attinmeta = TupleDescGetAttInMetadata(call_state->ret_tupdesc);
3386
3387 CurrentResourceOwner = oldowner;
3388 MemoryContextSwitchTo(oldcxt);
3389}

References ReturnSetInfo::allowedModes, Assert, CurrentResourceOwner, ReturnSetInfo::expectedDesc, fb(), MemoryContextSwitchTo(), SFRM_Materialize_Random, TupleDescGetAttInMetadata(), tuplestore_begin_heap(), and work_mem.

Referenced by pltcl_returnnext().

◆ pltcl_InitNotifier()

static ClientData pltcl_InitNotifier ( void  )
static

Definition at line 356 of file pltcl.c.

357{
358 static int fakeThreadKey; /* To give valid address for ClientData */
359
360 return (ClientData) &(fakeThreadKey);
361}

References fb().

Referenced by _PG_init().

◆ pltcl_process_SPI_result()

static int pltcl_process_SPI_result ( Tcl_Interp *  interp,
const char *  arrayname,
Tcl_Obj *  loop_body,
int  spi_rc,
SPITupleTable *  tuptable,
uint64  ntuples 
)
static

Definition at line 2520 of file pltcl.c.

2526{
2527 int my_rc = TCL_OK;
2528 int loop_rc;
2529 HeapTuple *tuples;
2530 TupleDesc tupdesc;
2531
2532 switch (spi_rc)
2533 {
2534 case SPI_OK_SELINTO:
2535 case SPI_OK_INSERT:
2536 case SPI_OK_DELETE:
2537 case SPI_OK_UPDATE:
2538 case SPI_OK_MERGE:
2539 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(ntuples));
2540 break;
2541
2542 case SPI_OK_UTILITY:
2543 case SPI_OK_REWRITTEN:
2544 if (tuptable == NULL)
2545 {
2546 Tcl_SetObjResult(interp, Tcl_NewIntObj(0));
2547 break;
2548 }
2549 /* fall through for utility returning tuples */
2550 pg_fallthrough;
2551
2552 case SPI_OK_SELECT:
2553 case SPI_OK_INSERT_RETURNING:
2554 case SPI_OK_DELETE_RETURNING:
2555 case SPI_OK_UPDATE_RETURNING:
2556 case SPI_OK_MERGE_RETURNING:
2557
2558 /*
2559 * Process the tuples we got
2560 */
2561 tuples = tuptable->vals;
2562 tupdesc = tuptable->tupdesc;
2563
2564 if (loop_body == NULL)
2565 {
2566 /*
2567 * If there is no loop body given, just set the variables from
2568 * the first tuple (if any)
2569 */
2570 if (ntuples > 0)
2571 pltcl_set_tuple_values(interp, arrayname, 0,
2572 tuples[0], tupdesc);
2573 }
2574 else
2575 {
2576 /*
2577 * There is a loop body - process all tuples and evaluate the
2578 * body on each
2579 */
2580 uint64 i;
2581
2582 for (i = 0; i < ntuples; i++)
2583 {
2584 pltcl_set_tuple_values(interp, arrayname, i,
2585 tuples[i], tupdesc);
2586
2587 loop_rc = Tcl_EvalObjEx(interp, loop_body, 0);
2588
2589 if (loop_rc == TCL_OK)
2590 continue;
2591 if (loop_rc == TCL_CONTINUE)
2592 continue;
2593 if (loop_rc == TCL_RETURN)
2594 {
2595 my_rc = TCL_RETURN;
2596 break;
2597 }
2598 if (loop_rc == TCL_BREAK)
2599 break;
2600 my_rc = TCL_ERROR;
2601 break;
2602 }
2603 }
2604
2605 if (my_rc == TCL_OK)
2606 {
2607 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(ntuples));
2608 }
2609 break;
2610
2611 default:
2612 Tcl_AppendResult(interp, "pltcl: SPI_execute failed: ",
2613 SPI_result_code_string(spi_rc), NULL);
2614 my_rc = TCL_ERROR;
2615 break;
2616 }
2617
2618 SPI_freetuptable(tuptable);
2619
2620 return my_rc;
2621}

References fb(), i, pg_fallthrough, pltcl_set_tuple_values(), SPI_freetuptable(), SPI_OK_DELETE, SPI_OK_DELETE_RETURNING, SPI_OK_INSERT, SPI_OK_INSERT_RETURNING, SPI_OK_MERGE, SPI_OK_MERGE_RETURNING, SPI_OK_REWRITTEN, SPI_OK_SELECT, SPI_OK_SELINTO, SPI_OK_UPDATE, SPI_OK_UPDATE_RETURNING, SPI_OK_UTILITY, SPI_result_code_string(), SPITupleTable::tupdesc, and SPITupleTable::vals.

Referenced by pltcl_SPI_execute(), and pltcl_SPI_execute_plan().

◆ pltcl_quote()

static int pltcl_quote ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2095 of file pltcl.c.

2097{
2098 char *tmp;
2099 const char *cp1;
2100 char *cp2;
2101 Tcl_Size length;
2102
2103 /************************************************************
2104 * Check call syntax
2105 ************************************************************/
2106 if (objc != 2)
2107 {
2108 Tcl_WrongNumArgs(interp, 1, objv, "string");
2109 return TCL_ERROR;
2110 }
2111
2112 /************************************************************
2113 * Allocate space for the maximum the string can
2114 * grow to and initialize pointers
2115 ************************************************************/
2116 cp1 = Tcl_GetStringFromObj(objv[1], &length);
2117 tmp = palloc(length * 2 + 1);
2118 cp2 = tmp;
2119
2120 /************************************************************
2121 * Walk through string and double every quote and backslash
2122 ************************************************************/
2123 while (*cp1)
2124 {
2125 if (*cp1 == '\'')
2126 *cp2++ = '\'';
2127 else
2128 {
2129 if (*cp1 == '\\')
2130 *cp2++ = '\\';
2131 }
2132 *cp2++ = *cp1++;
2133 }
2134
2135 /************************************************************
2136 * Terminate the string and set it as result
2137 ************************************************************/
2138 *cp2 = '\0';
2139 Tcl_SetObjResult(interp, Tcl_NewStringObj(tmp, -1));
2140 pfree(tmp);
2141 return TCL_OK;
2142}

References fb(), palloc(), and pfree().

Referenced by pltcl_init_interp().

◆ pltcl_returnnext()

static int pltcl_returnnext ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2241 of file pltcl.c.

2243{
2244 pltcl_call_state *call_state = pltcl_current_call_state;
2245 FunctionCallInfo fcinfo = call_state->fcinfo;
2246 pltcl_proc_desc *prodesc = call_state->prodesc;
2247 MemoryContext oldcontext = CurrentMemoryContext;
2248 ResourceOwner oldowner = CurrentResourceOwner;
2249 volatile int result = TCL_OK;
2250
2251 /*
2252 * Check that we're called as a set-returning function
2253 */
2254 if (fcinfo == NULL)
2255 {
2256 Tcl_SetObjResult(interp,
2257 Tcl_NewStringObj("return_next cannot be used in triggers", -1));
2258 return TCL_ERROR;
2259 }
2260
2261 if (!prodesc->fn_retisset)
2262 {
2263 Tcl_SetObjResult(interp,
2264 Tcl_NewStringObj("return_next cannot be used in non-set-returning functions", -1));
2265 return TCL_ERROR;
2266 }
2267
2268 /*
2269 * Check call syntax
2270 */
2271 if (objc != 2)
2272 {
2273 Tcl_WrongNumArgs(interp, 1, objv, "result");
2274 return TCL_ERROR;
2275 }
2276
2277 /*
2278 * The rest might throw elog(ERROR), so must run in a subtransaction.
2279 *
2280 * A small advantage of using a subtransaction is that it provides a
2281 * short-lived memory context for free, so we needn't worry about leaking
2282 * memory here. To use that context, call BeginInternalSubTransaction
2283 * directly instead of going through pltcl_subtrans_begin.
2284 */
2285 BeginInternalSubTransaction(NULL);
2286 PG_TRY();
2287 {
2288 /* Set up tuple store if first output row */
2289 if (call_state->tuple_store == NULL)
2290 pltcl_init_tuple_store(call_state);
2291
2292 if (prodesc->fn_retistuple)
2293 {
2294 Tcl_Obj **rowObjv;
2295 Tcl_Size rowObjc;
2296
2297 /* result should be a list, so break it down */
2298 if (Tcl_ListObjGetElements(interp, objv[1], &rowObjc, &rowObjv) == TCL_ERROR)
2299 result = TCL_ERROR;
2300 else
2301 {
2302 HeapTuple tuple;
2303
2304 tuple = pltcl_build_tuple_result(interp, rowObjv, rowObjc,
2305 call_state);
2306 tuplestore_puttuple(call_state->tuple_store, tuple);
2307 }
2308 }
2309 else
2310 {
2311 Datum retval;
2312 bool isNull = false;
2313
2314 /* for paranoia's sake, check that tupdesc has exactly one column */
2315 if (call_state->ret_tupdesc->natts != 1)
2316 elog(ERROR, "wrong result type supplied in return_next");
2317
2318 retval = InputFunctionCall(&prodesc->result_in_func,
2319 utf_u2e((char *) Tcl_GetString(objv[1])),
2320 prodesc->result_typioparam,
2321 -1);
2322 tuplestore_putvalues(call_state->tuple_store, call_state->ret_tupdesc,
2323 &retval, &isNull);
2324 }
2325
2326 pltcl_subtrans_commit(oldcontext, oldowner);
2327 }
2328 PG_CATCH();
2329 {
2330 pltcl_subtrans_abort(interp, oldcontext, oldowner);
2331 return TCL_ERROR;
2332 }
2333 PG_END_TRY();
2334
2335 return result;
2336}

References BeginInternalSubTransaction(), CurrentMemoryContext, CurrentResourceOwner, elog, ERROR, fb(), pltcl_proc_desc::fn_retisset, pltcl_proc_desc::fn_retistuple, InputFunctionCall(), PG_CATCH, PG_END_TRY, PG_TRY, pltcl_build_tuple_result(), pltcl_current_call_state, pltcl_init_tuple_store(), pltcl_subtrans_abort(), pltcl_subtrans_commit(), result, pltcl_proc_desc::result_in_func, pltcl_proc_desc::result_typioparam, tuplestore_puttuple(), tuplestore_putvalues(), and utf_u2e().

Referenced by pltcl_init_interp().

◆ pltcl_returnnull()

static int pltcl_returnnull ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2203 of file pltcl.c.

2205{
2206 FunctionCallInfo fcinfo = pltcl_current_call_state->fcinfo;
2207
2208 /************************************************************
2209 * Check call syntax
2210 ************************************************************/
2211 if (objc != 1)
2212 {
2213 Tcl_WrongNumArgs(interp, 1, objv, "");
2214 return TCL_ERROR;
2215 }
2216
2217 /************************************************************
2218 * Check that we're called as a normal function
2219 ************************************************************/
2220 if (fcinfo == NULL)
2221 {
2222 Tcl_SetObjResult(interp,
2223 Tcl_NewStringObj("return_null cannot be used in triggers", -1));
2224 return TCL_ERROR;
2225 }
2226
2227 /************************************************************
2228 * Set the NULL return flag and cause Tcl to return from the
2229 * procedure.
2230 ************************************************************/
2231 fcinfo->isnull = true;
2232
2233 return TCL_RETURN;
2234}

References fb(), pltcl_call_state::fcinfo, FunctionCallInfoBaseData::isnull, and pltcl_current_call_state.

Referenced by pltcl_init_interp().

◆ pltcl_rollback()

static int pltcl_rollback ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 3064 of file pltcl.c.

3066{
3067 MemoryContext oldcontext = CurrentMemoryContext;
3068
3069 PG_TRY();
3070 {
3071 SPI_rollback();
3072 }
3073 PG_CATCH();
3074 {
3075 ErrorData *edata;
3076
3077 /* Save error info */
3078 MemoryContextSwitchTo(oldcontext);
3079 edata = CopyErrorData();
3080 FlushErrorState();
3081
3082 /* Pass the error data to Tcl */
3083 pltcl_construct_errorCode(interp, edata);
3084 UTF_BEGIN;
3085 Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
3086 UTF_END;
3087 FreeErrorData(edata);
3088
3089 return TCL_ERROR;
3090 }
3091 PG_END_TRY();
3092
3093 return TCL_OK;
3094}

References CopyErrorData(), CurrentMemoryContext, fb(), FlushErrorState(), FreeErrorData(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_TRY, pltcl_construct_errorCode(), SPI_rollback(), UTF_BEGIN, UTF_E2U, and UTF_END.

Referenced by pltcl_init_interp().

◆ pltcl_ServiceModeHook()

static void pltcl_ServiceModeHook ( int  mode)
static

Definition at line 390 of file pltcl.c.

391{
392}

Referenced by _PG_init().

◆ pltcl_set_tuple_values()

static void pltcl_set_tuple_values ( Tcl_Interp *  interp,
const char *  arrayname,
uint64  tupno,
HeapTuple  tuple,
TupleDesc  tupdesc 
)
static

Definition at line 3104 of file pltcl.c.

3106{
3107 int i;
3108 char *outputstr;
3109 Datum attr;
3110 bool isnull;
3111 const char *attname;
3112 Oid typoutput;
3113 bool typisvarlena;
3114 const char **arrptr;
3115 const char **nameptr;
3116 const char *nullname = NULL;
3117
3118 /************************************************************
3119 * Prepare pointers for Tcl_SetVar2Ex() below
3120 ************************************************************/
3121 if (arrayname == NULL)
3122 {
3123 arrptr = &attname;
3124 nameptr = &nullname;
3125 }
3126 else
3127 {
3128 arrptr = &arrayname;
3129 nameptr = &attname;
3130
3131 /*
3132 * When outputting to an array, fill the ".tupno" element with the
3133 * current tuple number. This will be overridden below if ".tupno" is
3134 * in use as an actual field name in the rowtype.
3135 */
3136 Tcl_SetVar2Ex(interp, arrayname, ".tupno", Tcl_NewWideIntObj(tupno), 0);
3137 }
3138
3139 for (i = 0; i < tupdesc->natts; i++)
3140 {
3141 Form_pg_attribute att = TupleDescAttr(tupdesc, i);
3142
3143 /* ignore dropped attributes */
3144 if (att->attisdropped)
3145 continue;
3146
3147 /************************************************************
3148 * Get the attribute name
3149 ************************************************************/
3150 UTF_BEGIN;
3151 attname = pstrdup(UTF_E2U(NameStr(att->attname)));
3152 UTF_END;
3153
3154 /************************************************************
3155 * Get the attributes value
3156 ************************************************************/
3157 attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
3158
3159 /************************************************************
3160 * If there is a value, set the variable
3161 * If not, unset it
3162 *
3163 * Hmmm - Null attributes will cause functions to
3164 * crash if they don't expect them - need something
3165 * smarter here.
3166 ************************************************************/
3167 if (!isnull)
3168 {
3169 getTypeOutputInfo(att->atttypid, &typoutput, &typisvarlena);
3170 outputstr = OidOutputFunctionCall(typoutput, attr);
3171 UTF_BEGIN;
3172 Tcl_SetVar2Ex(interp, *arrptr, *nameptr,
3173 Tcl_NewStringObj(UTF_E2U(outputstr), -1), 0);
3174 UTF_END;
3175 pfree(outputstr);
3176 }
3177 else
3178 Tcl_UnsetVar2(interp, *arrptr, *nameptr, 0);
3179
3180 pfree(unconstify(char *, attname));
3181 }
3182}

References attname, fb(), getTypeOutputInfo(), heap_getattr(), i, NameStr, TupleDescData::natts, OidOutputFunctionCall(), pfree(), pstrdup(), TupleDescAttr(), unconstify, UTF_BEGIN, UTF_E2U, and UTF_END.

Referenced by pltcl_process_SPI_result().

◆ pltcl_SetTimer()

static void pltcl_SetTimer ( CONST86 Tcl_Time *  timePtr)
static

Definition at line 369 of file pltcl.c.

370{
371}

Referenced by _PG_init().

◆ pltcl_SPI_execute()

static int pltcl_SPI_execute ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2411 of file pltcl.c.

2413{
2414 int my_rc;
2415 int spi_rc;
2416 int query_idx;
2417 int i;
2418 int optIndex;
2419 int count = 0;
2420 const char *volatile arrayname = NULL;
2421 Tcl_Obj *volatile loop_body = NULL;
2422 MemoryContext oldcontext = CurrentMemoryContext;
2423 ResourceOwner oldowner = CurrentResourceOwner;
2424
2425 enum options
2426 {
2427 OPT_ARRAY, OPT_COUNT
2428 };
2429
2430 static const char *options[] = {
2431 "-array", "-count", (const char *) NULL
2432 };
2433
2434 /************************************************************
2435 * Check the call syntax and get the options
2436 ************************************************************/
2437 if (objc < 2)
2438 {
2439 Tcl_WrongNumArgs(interp, 1, objv,
2440 "?-count n? ?-array name? query ?loop body?");
2441 return TCL_ERROR;
2442 }
2443
2444 i = 1;
2445 while (i < objc)
2446 {
2447 if (Tcl_GetIndexFromObj(NULL, objv[i], options, NULL,
2448 TCL_EXACT, &optIndex) != TCL_OK)
2449 break;
2450
2451 if (++i >= objc)
2452 {
2453 Tcl_SetObjResult(interp,
2454 Tcl_NewStringObj("missing argument to -count or -array", -1));
2455 return TCL_ERROR;
2456 }
2457
2458 switch ((enum options) optIndex)
2459 {
2460 case OPT_ARRAY:
2461 arrayname = Tcl_GetString(objv[i++]);
2462 break;
2463
2464 case OPT_COUNT:
2465 if (Tcl_GetIntFromObj(interp, objv[i++], &count) != TCL_OK)
2466 return TCL_ERROR;
2467 break;
2468 }
2469 }
2470
2471 query_idx = i;
2472 if (query_idx >= objc || query_idx + 2 < objc)
2473 {
2474 Tcl_WrongNumArgs(interp, query_idx - 1, objv, "query ?loop body?");
2475 return TCL_ERROR;
2476 }
2477
2478 if (query_idx + 1 < objc)
2479 loop_body = objv[query_idx + 1];
2480
2481 /************************************************************
2482 * Execute the query inside a sub-transaction, so we can cope with
2483 * errors sanely
2484 ************************************************************/
2485
2486 pltcl_subtrans_begin(oldcontext, oldowner);
2487
2488 PG_TRY();
2489 {
2490 UTF_BEGIN;
2491 spi_rc = SPI_execute(UTF_U2E(Tcl_GetString(objv[query_idx])),
2492 pltcl_current_call_state->prodesc->fn_readonly, count);
2493 UTF_END;
2494
2495 my_rc = pltcl_process_SPI_result(interp,
2496 arrayname,
2497 loop_body,
2498 spi_rc,
2499 SPI_tuptable,
2500 SPI_processed);
2501
2502 pltcl_subtrans_commit(oldcontext, oldowner);
2503 }
2504 PG_CATCH();
2505 {
2506 pltcl_subtrans_abort(interp, oldcontext, oldowner);
2507 return TCL_ERROR;
2508 }
2509 PG_END_TRY();
2510
2511 return my_rc;
2512}

References CurrentMemoryContext, CurrentResourceOwner, fb(), pltcl_proc_desc::fn_readonly, i, PG_CATCH, PG_END_TRY, PG_TRY, pltcl_current_call_state, pltcl_process_SPI_result(), pltcl_subtrans_abort(), pltcl_subtrans_begin(), pltcl_subtrans_commit(), pltcl_call_state::prodesc, SPI_execute(), SPI_processed, SPI_tuptable, UTF_BEGIN, UTF_END, and UTF_U2E.

Referenced by pltcl_init_interp().

◆ pltcl_SPI_execute_plan()

static int pltcl_SPI_execute_plan ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2761 of file pltcl.c.

2763{
2764 int my_rc;
2765 int spi_rc;
2766 int i;
2767 int j;
2768 int optIndex;
2769 Tcl_HashEntry *hashent;
2770 pltcl_query_desc *qdesc;
2771 const char *nulls = NULL;
2772 const char *arrayname = NULL;
2773 Tcl_Obj *loop_body = NULL;
2774 int count = 0;
2775 Tcl_Size callObjc;
2776 Tcl_Obj **callObjv = NULL;
2777 Datum *argvalues;
2778 MemoryContext oldcontext = CurrentMemoryContext;
2779 ResourceOwner oldowner = CurrentResourceOwner;
2780 Tcl_HashTable *query_hash;
2781
2782 enum options
2783 {
2784 OPT_ARRAY, OPT_COUNT, OPT_NULLS
2785 };
2786
2787 static const char *options[] = {
2788 "-array", "-count", "-nulls", (const char *) NULL
2789 };
2790
2791 /************************************************************
2792 * Get the options and check syntax
2793 ************************************************************/
2794 i = 1;
2795 while (i < objc)
2796 {
2797 if (Tcl_GetIndexFromObj(NULL, objv[i], options, NULL,
2798 TCL_EXACT, &optIndex) != TCL_OK)
2799 break;
2800
2801 if (++i >= objc)
2802 {
2803 Tcl_SetObjResult(interp,
2804 Tcl_NewStringObj("missing argument to -array, -count or -nulls", -1));
2805 return TCL_ERROR;
2806 }
2807
2808 switch ((enum options) optIndex)
2809 {
2810 case OPT_ARRAY:
2811 arrayname = Tcl_GetString(objv[i++]);
2812 break;
2813
2814 case OPT_COUNT:
2815 if (Tcl_GetIntFromObj(interp, objv[i++], &count) != TCL_OK)
2816 return TCL_ERROR;
2817 break;
2818
2819 case OPT_NULLS:
2820 nulls = Tcl_GetString(objv[i++]);
2821 break;
2822 }
2823 }
2824
2825 /************************************************************
2826 * Get the prepared plan descriptor by its key
2827 ************************************************************/
2828 if (i >= objc)
2829 {
2830 Tcl_SetObjResult(interp,
2831 Tcl_NewStringObj("missing argument to -count or -array", -1));
2832 return TCL_ERROR;
2833 }
2834
2835 query_hash = &pltcl_current_call_state->prodesc->interp_desc->query_hash;
2836
2837 hashent = Tcl_FindHashEntry(query_hash, Tcl_GetString(objv[i]));
2838 if (hashent == NULL)
2839 {
2840 Tcl_AppendResult(interp, "invalid queryid '", Tcl_GetString(objv[i]), "'", NULL);
2841 return TCL_ERROR;
2842 }
2843 qdesc = (pltcl_query_desc *) Tcl_GetHashValue(hashent);
2844 i++;
2845
2846 /************************************************************
2847 * If a nulls string is given, check for correct length
2848 ************************************************************/
2849 if (nulls != NULL)
2850 {
2851 if (strlen(nulls) != qdesc->nargs)
2852 {
2853 Tcl_SetObjResult(interp,
2854 Tcl_NewStringObj("length of nulls string doesn't match number of arguments",
2855 -1));
2856 return TCL_ERROR;
2857 }
2858 }
2859
2860 /************************************************************
2861 * If there was an argtype list on preparation, we need
2862 * an argument value list now
2863 ************************************************************/
2864 if (qdesc->nargs > 0)
2865 {
2866 if (i >= objc)
2867 {
2868 Tcl_SetObjResult(interp,
2869 Tcl_NewStringObj("argument list length doesn't match number of arguments for query",
2870 -1));
2871 return TCL_ERROR;
2872 }
2873
2874 /************************************************************
2875 * Split the argument values
2876 ************************************************************/
2877 if (Tcl_ListObjGetElements(interp, objv[i++], &callObjc, &callObjv) != TCL_OK)
2878 return TCL_ERROR;
2879
2880 /************************************************************
2881 * Check that the number of arguments matches
2882 ************************************************************/
2883 if (callObjc != qdesc->nargs)
2884 {
2885 Tcl_SetObjResult(interp,
2886 Tcl_NewStringObj("argument list length doesn't match number of arguments for query",
2887 -1));
2888 return TCL_ERROR;
2889 }
2890 }
2891 else
2892 callObjc = 0;
2893
2894 /************************************************************
2895 * Get loop body if present
2896 ************************************************************/
2897 if (i < objc)
2898 loop_body = objv[i++];
2899
2900 if (i != objc)
2901 {
2902 Tcl_WrongNumArgs(interp, 1, objv,
2903 "?-count n? ?-array name? ?-nulls string? "
2904 "query ?args? ?loop body?");
2905 return TCL_ERROR;
2906 }
2907
2908 /************************************************************
2909 * Execute the plan inside a sub-transaction, so we can cope with
2910 * errors sanely
2911 ************************************************************/
2912
2913 pltcl_subtrans_begin(oldcontext, oldowner);
2914
2915 PG_TRY();
2916 {
2917 /************************************************************
2918 * Setup the value array for SPI_execute_plan() using
2919 * the type specific input functions
2920 ************************************************************/
2921 argvalues = (Datum *) palloc(callObjc * sizeof(Datum));
2922
2923 for (j = 0; j < callObjc; j++)
2924 {
2925 if (nulls && nulls[j] == 'n')
2926 {
2927 argvalues[j] = InputFunctionCall(&qdesc->arginfuncs[j],
2928 NULL,
2929 qdesc->argtypioparams[j],
2930 -1);
2931 }
2932 else
2933 {
2934 UTF_BEGIN;
2935 argvalues[j] = InputFunctionCall(&qdesc->arginfuncs[j],
2936 UTF_U2E(Tcl_GetString(callObjv[j])),
2937 qdesc->argtypioparams[j],
2938 -1);
2939 UTF_END;
2940 }
2941 }
2942
2943 /************************************************************
2944 * Execute the plan
2945 ************************************************************/
2946 spi_rc = SPI_execute_plan(qdesc->plan, argvalues, nulls,
2947 pltcl_current_call_state->prodesc->fn_readonly,
2948 count);
2949
2950 my_rc = pltcl_process_SPI_result(interp,
2951 arrayname,
2952 loop_body,
2953 spi_rc,
2954 SPI_tuptable,
2955 SPI_processed);
2956
2957 pltcl_subtrans_commit(oldcontext, oldowner);
2958 }
2959 PG_CATCH();
2960 {
2961 pltcl_subtrans_abort(interp, oldcontext, oldowner);
2962 return TCL_ERROR;
2963 }
2964 PG_END_TRY();
2965
2966 return my_rc;
2967}

References CurrentMemoryContext, CurrentResourceOwner, fb(), pltcl_proc_desc::fn_readonly, i, InputFunctionCall(), pltcl_proc_desc::interp_desc, j, palloc(), PG_CATCH, PG_END_TRY, PG_TRY, pltcl_current_call_state, pltcl_process_SPI_result(), pltcl_subtrans_abort(), pltcl_subtrans_begin(), pltcl_subtrans_commit(), pltcl_call_state::prodesc, pltcl_interp_desc::query_hash, SPI_execute_plan(), SPI_processed, SPI_tuptable, UTF_BEGIN, UTF_END, and UTF_U2E.

Referenced by pltcl_init_interp().

◆ pltcl_SPI_prepare()

static int pltcl_SPI_prepare ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2633 of file pltcl.c.

2635{
2636 volatile MemoryContext plan_cxt = NULL;
2637 Tcl_Size nargs;
2638 Tcl_Obj **argsObj;
2639 pltcl_query_desc *qdesc;
2640 int i;
2641 Tcl_HashEntry *hashent;
2642 int hashnew;
2643 Tcl_HashTable *query_hash;
2644 MemoryContext oldcontext = CurrentMemoryContext;
2645 ResourceOwner oldowner = CurrentResourceOwner;
2646
2647 /************************************************************
2648 * Check the call syntax
2649 ************************************************************/
2650 if (objc != 3)
2651 {
2652 Tcl_WrongNumArgs(interp, 1, objv, "query argtypes");
2653 return TCL_ERROR;
2654 }
2655
2656 /************************************************************
2657 * Split the argument type list
2658 ************************************************************/
2659 if (Tcl_ListObjGetElements(interp, objv[2], &nargs, &argsObj) != TCL_OK)
2660 return TCL_ERROR;
2661
2662 /************************************************************
2663 * Allocate the new querydesc structure
2664 *
2665 * struct qdesc and subsidiary data all live in plan_cxt. Note that if the
2666 * function is recompiled for whatever reason, permanent memory leaks
2667 * occur. FIXME someday.
2668 ************************************************************/
2669 plan_cxt = AllocSetContextCreate(TopMemoryContext,
2670 "PL/Tcl spi_prepare query",
2671 ALLOCSET_SMALL_SIZES);
2672 MemoryContextSwitchTo(plan_cxt);
2673 qdesc = palloc0_object(pltcl_query_desc);
2674 snprintf(qdesc->qname, sizeof(qdesc->qname), "%p", qdesc);
2675 qdesc->nargs = nargs;
2676 qdesc->argtypes = (Oid *) palloc(nargs * sizeof(Oid));
2677 qdesc->arginfuncs = (FmgrInfo *) palloc(nargs * sizeof(FmgrInfo));
2678 qdesc->argtypioparams = (Oid *) palloc(nargs * sizeof(Oid));
2679 MemoryContextSwitchTo(oldcontext);
2680
2681 /************************************************************
2682 * Execute the prepare inside a sub-transaction, so we can cope with
2683 * errors sanely
2684 ************************************************************/
2685
2686 pltcl_subtrans_begin(oldcontext, oldowner);
2687
2688 PG_TRY();
2689 {
2690 /************************************************************
2691 * Resolve argument type names and then look them up by oid
2692 * in the system cache, and remember the required information
2693 * for input conversion.
2694 ************************************************************/
2695 for (i = 0; i < nargs; i++)
2696 {
2697 Oid typId,
2698 typInput,
2699 typIOParam;
2700 int32 typmod;
2701
2702 (void) parseTypeString(Tcl_GetString(argsObj[i]),
2703 &typId, &typmod, NULL);
2704
2705 getTypeInputInfo(typId, &typInput, &typIOParam);
2706
2707 qdesc->argtypes[i] = typId;
2708 fmgr_info_cxt(typInput, &(qdesc->arginfuncs[i]), plan_cxt);
2709 qdesc->argtypioparams[i] = typIOParam;
2710 }
2711
2712 /************************************************************
2713 * Prepare the plan and check for errors
2714 ************************************************************/
2715 UTF_BEGIN;
2716 qdesc->plan = SPI_prepare(UTF_U2E(Tcl_GetString(objv[1])),
2717 nargs, qdesc->argtypes);
2718 UTF_END;
2719
2720 if (qdesc->plan == NULL)
2721 elog(ERROR, "SPI_prepare() failed");
2722
2723 /************************************************************
2724 * Save the plan into permanent memory (right now it's in the
2725 * SPI procCxt, which will go away at function end).
2726 ************************************************************/
2727 if (SPI_keepplan(qdesc->plan))
2728 elog(ERROR, "SPI_keepplan() failed");
2729
2730 pltcl_subtrans_commit(oldcontext, oldowner);
2731 }
2732 PG_CATCH();
2733 {
2734 pltcl_subtrans_abort(interp, oldcontext, oldowner);
2735
2736 MemoryContextDelete(plan_cxt);
2737
2738 return TCL_ERROR;
2739 }
2740 PG_END_TRY();
2741
2742 /************************************************************
2743 * Insert a hashtable entry for the plan and return
2744 * the key to the caller
2745 ************************************************************/
2746 query_hash = &pltcl_current_call_state->prodesc->interp_desc->query_hash;
2747
2748 hashent = Tcl_CreateHashEntry(query_hash, qdesc->qname, &hashnew);
2749 Tcl_SetHashValue(hashent, (ClientData) qdesc);
2750
2751 /* qname is ASCII, so no need for encoding conversion */
2752 Tcl_SetObjResult(interp, Tcl_NewStringObj(qdesc->qname, -1));
2753 return TCL_OK;
2754}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, CurrentMemoryContext, CurrentResourceOwner, elog, ERROR, fb(), fmgr_info_cxt(), getTypeInputInfo(), i, pltcl_proc_desc::interp_desc, MemoryContextDelete(), MemoryContextSwitchTo(), palloc(), palloc0_object, parseTypeString(), PG_CATCH, PG_END_TRY, PG_TRY, pltcl_current_call_state, pltcl_subtrans_abort(), pltcl_subtrans_begin(), pltcl_subtrans_commit(), pltcl_call_state::prodesc, pltcl_interp_desc::query_hash, snprintf, SPI_keepplan(), SPI_prepare(), TopMemoryContext, UTF_BEGIN, UTF_END, and UTF_U2E.

Referenced by pltcl_init_interp().

◆ pltcl_subtrans_abort()

static void pltcl_subtrans_abort ( Tcl_Interp *  interp,
MemoryContext  oldcontext,
ResourceOwner  oldowner 
)
static

Definition at line 2382 of file pltcl.c.

2384{
2385 ErrorData *edata;
2386
2387 /* Save error info */
2388 MemoryContextSwitchTo(oldcontext);
2389 edata = CopyErrorData();
2390 FlushErrorState();
2391
2392 /* Abort the inner transaction */
2393 RollbackAndReleaseCurrentSubTransaction();
2394 MemoryContextSwitchTo(oldcontext);
2395 CurrentResourceOwner = oldowner;
2396
2397 /* Pass the error data to Tcl */
2398 pltcl_construct_errorCode(interp, edata);
2399 UTF_BEGIN;
2400 Tcl_SetObjResult(interp, Tcl_NewStringObj(UTF_E2U(edata->message), -1));
2401 UTF_END;
2402 FreeErrorData(edata);
2403}

References CopyErrorData(), CurrentResourceOwner, fb(), FlushErrorState(), FreeErrorData(), MemoryContextSwitchTo(), pltcl_construct_errorCode(), RollbackAndReleaseCurrentSubTransaction(), UTF_BEGIN, UTF_E2U, and UTF_END.

Referenced by pltcl_returnnext(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), and pltcl_SPI_prepare().

◆ pltcl_subtrans_begin()

static void pltcl_subtrans_begin ( MemoryContext  oldcontext,
ResourceOwner  oldowner 
)
static

Definition at line 2364 of file pltcl.c.

2365{
2366 BeginInternalSubTransaction(NULL);
2367
2368 /* Want to run inside function's memory context */
2369 MemoryContextSwitchTo(oldcontext);
2370}

References BeginInternalSubTransaction(), fb(), and MemoryContextSwitchTo().

Referenced by pltcl_SPI_execute(), pltcl_SPI_execute_plan(), and pltcl_SPI_prepare().

◆ pltcl_subtrans_commit()

static void pltcl_subtrans_commit ( MemoryContext  oldcontext,
ResourceOwner  oldowner 
)
static

Definition at line 2373 of file pltcl.c.

2374{
2375 /* Commit the inner transaction, return to outer xact context */
2376 ReleaseCurrentSubTransaction();
2377 MemoryContextSwitchTo(oldcontext);
2378 CurrentResourceOwner = oldowner;
2379}

References CurrentResourceOwner, MemoryContextSwitchTo(), and ReleaseCurrentSubTransaction().

Referenced by pltcl_returnnext(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), and pltcl_SPI_prepare().

◆ pltcl_subtransaction()

static int pltcl_subtransaction ( ClientData  cdata,
Tcl_Interp *  interp,
int  objc,
Tcl_Obj *const  objv[] 
)
static

Definition at line 2977 of file pltcl.c.

2979{
2980 MemoryContext oldcontext = CurrentMemoryContext;
2981 ResourceOwner oldowner = CurrentResourceOwner;
2982 int retcode;
2983
2984 if (objc != 2)
2985 {
2986 Tcl_WrongNumArgs(interp, 1, objv, "command");
2987 return TCL_ERROR;
2988 }
2989
2990 /*
2991 * Note: we don't use pltcl_subtrans_begin and friends here because we
2992 * don't want the error handling in pltcl_subtrans_abort. But otherwise
2993 * the processing should be about the same as in those functions.
2994 */
2995 BeginInternalSubTransaction(NULL);
2996 MemoryContextSwitchTo(oldcontext);
2997
2998 retcode = Tcl_EvalObjEx(interp, objv[1], 0);
2999
3000 if (retcode == TCL_ERROR)
3001 {
3002 /* Rollback the subtransaction */
3003 RollbackAndReleaseCurrentSubTransaction();
3004 }
3005 else
3006 {
3007 /* Commit the subtransaction */
3008 ReleaseCurrentSubTransaction();
3009 }
3010
3011 /* In either case, restore previous memory context and resource owner */
3012 MemoryContextSwitchTo(oldcontext);
3013 CurrentResourceOwner = oldowner;
3014
3015 return retcode;
3016}

References BeginInternalSubTransaction(), CurrentMemoryContext, CurrentResourceOwner, fb(), MemoryContextSwitchTo(), ReleaseCurrentSubTransaction(), and RollbackAndReleaseCurrentSubTransaction().

Referenced by pltcl_init_interp().

◆ pltcl_trigger_handler()

static HeapTuple pltcl_trigger_handler ( PG_FUNCTION_ARGS  ,
pltcl_call_state *  call_state,
bool  pltrusted 
)
static

Definition at line 1061 of file pltcl.c.

1063{
1064 pltcl_proc_desc *prodesc;
1065 Tcl_Interp *volatile interp;
1066 TriggerData *trigdata = (TriggerData *) fcinfo->context;
1067 char *stroid;
1068 TupleDesc tupdesc;
1069 volatile HeapTuple rettup;
1070 Tcl_Obj *tcl_cmd;
1071 Tcl_Obj *tcl_trigtup;
1072 int tcl_rc;
1073 int i;
1074 const char *result;
1075 Tcl_Size result_Objc;
1076 Tcl_Obj **result_Objv;
1077 int rc PG_USED_FOR_ASSERTS_ONLY;
1078
1079 call_state->trigdata = trigdata;
1080
1081 /* Connect to SPI manager */
1082 SPI_connect();
1083
1084 /* Make transition tables visible to this SPI connection */
1085 rc = SPI_register_trigger_data(trigdata);
1086 Assert(rc >= 0);
1087
1088 /* Find or compile the function */
1089 prodesc = compile_pltcl_function(fcinfo->flinfo->fn_oid,
1090 RelationGetRelid(trigdata->tg_relation),
1091 false, /* not an event trigger */
1092 pltrusted);
1093
1094 call_state->prodesc = prodesc;
1095 prodesc->fn_refcount++;
1096
1097 interp = prodesc->interp_desc->interp;
1098
1099 tupdesc = RelationGetDescr(trigdata->tg_relation);
1100
1101 /************************************************************
1102 * Create the tcl command to call the internal
1103 * proc in the interpreter
1104 ************************************************************/
1105 tcl_cmd = Tcl_NewObj();
1106 Tcl_IncrRefCount(tcl_cmd);
1107
1108 PG_TRY();
1109 {
1110 /* The procedure name (note this is all ASCII, so no utf_e2u) */
1111 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1112 Tcl_NewStringObj(prodesc->internal_proname, -1));
1113
1114 /* The trigger name for argument TG_name */
1115 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1116 Tcl_NewStringObj(utf_e2u(trigdata->tg_trigger->tgname), -1));
1117
1118 /* The oid of the trigger relation for argument TG_relid */
1119 /* Consider not converting to a string for more performance? */
1120 stroid = DatumGetCString(DirectFunctionCall1(oidout,
1121 ObjectIdGetDatum(trigdata->tg_relation->rd_id)));
1122 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1123 Tcl_NewStringObj(stroid, -1));
1124 pfree(stroid);
1125
1126 /* The name of the table the trigger is acting on: TG_table_name */
1127 stroid = SPI_getrelname(trigdata->tg_relation);
1128 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1129 Tcl_NewStringObj(utf_e2u(stroid), -1));
1130 pfree(stroid);
1131
1132 /* The schema of the table the trigger is acting on: TG_table_schema */
1133 stroid = SPI_getnspname(trigdata->tg_relation);
1134 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1135 Tcl_NewStringObj(utf_e2u(stroid), -1));
1136 pfree(stroid);
1137
1138 /* A list of attribute names for argument TG_relatts */
1139 tcl_trigtup = Tcl_NewObj();
1140 Tcl_ListObjAppendElement(NULL, tcl_trigtup, Tcl_NewObj());
1141 for (i = 0; i < tupdesc->natts; i++)
1142 {
1143 Form_pg_attribute att = TupleDescAttr(tupdesc, i);
1144
1145 if (att->attisdropped)
1146 Tcl_ListObjAppendElement(NULL, tcl_trigtup, Tcl_NewObj());
1147 else
1148 Tcl_ListObjAppendElement(NULL, tcl_trigtup,
1149 Tcl_NewStringObj(utf_e2u(NameStr(att->attname)), -1));
1150 }
1151 Tcl_ListObjAppendElement(NULL, tcl_cmd, tcl_trigtup);
1152
1153 /* The when part of the event for TG_when */
1154 if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
1155 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1156 Tcl_NewStringObj("BEFORE", -1));
1157 else if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
1158 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1159 Tcl_NewStringObj("AFTER", -1));
1160 else if (TRIGGER_FIRED_INSTEAD(trigdata->tg_event))
1161 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1162 Tcl_NewStringObj("INSTEAD OF", -1));
1163 else
1164 elog(ERROR, "unrecognized WHEN tg_event: %u", trigdata->tg_event);
1165
1166 /* The level part of the event for TG_level */
1167 if (TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
1168 {
1169 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1170 Tcl_NewStringObj("ROW", -1));
1171
1172 /*
1173 * Now the command part of the event for TG_op and data for NEW
1174 * and OLD
1175 *
1176 * Note: In BEFORE trigger, stored generated columns are not
1177 * computed yet, so don't make them accessible in NEW row.
1178 */
1179 if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
1180 {
1181 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1182 Tcl_NewStringObj("INSERT", -1));
1183
1184 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1185 pltcl_build_tuple_argument(trigdata->tg_trigtuple,
1186 tupdesc,
1187 !TRIGGER_FIRED_BEFORE(trigdata->tg_event)));
1188 Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1189
1190 rettup = trigdata->tg_trigtuple;
1191 }
1192 else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
1193 {
1194 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1195 Tcl_NewStringObj("DELETE", -1));
1196
1197 Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1198 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1199 pltcl_build_tuple_argument(trigdata->tg_trigtuple,
1200 tupdesc,
1201 true));
1202
1203 rettup = trigdata->tg_trigtuple;
1204 }
1205 else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
1206 {
1207 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1208 Tcl_NewStringObj("UPDATE", -1));
1209
1210 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1211 pltcl_build_tuple_argument(trigdata->tg_newtuple,
1212 tupdesc,
1213 !TRIGGER_FIRED_BEFORE(trigdata->tg_event)));
1214 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1215 pltcl_build_tuple_argument(trigdata->tg_trigtuple,
1216 tupdesc,
1217 true));
1218
1219 rettup = trigdata->tg_newtuple;
1220 }
1221 else
1222 elog(ERROR, "unrecognized OP tg_event: %u", trigdata->tg_event);
1223 }
1224 else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
1225 {
1226 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1227 Tcl_NewStringObj("STATEMENT", -1));
1228
1229 if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
1230 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1231 Tcl_NewStringObj("INSERT", -1));
1232 else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
1233 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1234 Tcl_NewStringObj("DELETE", -1));
1235 else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
1236 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1237 Tcl_NewStringObj("UPDATE", -1));
1238 else if (TRIGGER_FIRED_BY_TRUNCATE(trigdata->tg_event))
1239 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1240 Tcl_NewStringObj("TRUNCATE", -1));
1241 else
1242 elog(ERROR, "unrecognized OP tg_event: %u", trigdata->tg_event);
1243
1244 Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1245 Tcl_ListObjAppendElement(NULL, tcl_cmd, Tcl_NewObj());
1246
1247 rettup = (HeapTuple) NULL;
1248 }
1249 else
1250 elog(ERROR, "unrecognized LEVEL tg_event: %u", trigdata->tg_event);
1251
1252 /* Finally append the arguments from CREATE TRIGGER */
1253 for (i = 0; i < trigdata->tg_trigger->tgnargs; i++)
1254 Tcl_ListObjAppendElement(NULL, tcl_cmd,
1255 Tcl_NewStringObj(utf_e2u(trigdata->tg_trigger->tgargs[i]), -1));
1256 }
1257 PG_CATCH();
1258 {
1259 Tcl_DecrRefCount(tcl_cmd);
1260 PG_RE_THROW();
1261 }
1262 PG_END_TRY();
1263
1264 /************************************************************
1265 * Call the Tcl function
1266 *
1267 * We assume no PG error can be thrown directly from this call.
1268 ************************************************************/
1269 tcl_rc = Tcl_EvalObjEx(interp, tcl_cmd, (TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL));
1270
1271 /* Release refcount to free tcl_cmd (and all subsidiary objects) */
1272 Tcl_DecrRefCount(tcl_cmd);
1273
1274 /************************************************************
1275 * Check for errors reported by Tcl.
1276 ************************************************************/
1277 if (tcl_rc != TCL_OK)
1278 throw_tcl_error(interp, prodesc->user_proname);
1279
1280 /************************************************************
1281 * Exit SPI environment.
1282 ************************************************************/
1283 if (SPI_finish() != SPI_OK_FINISH)
1284 elog(ERROR, "SPI_finish() failed");
1285
1286 /************************************************************
1287 * The return value from the procedure might be one of
1288 * the magic strings OK or SKIP, or a list from array get.
1289 * We can check for OK or SKIP without worrying about encoding.
1290 ************************************************************/
1291 result = Tcl_GetStringResult(interp);
1292
1293 if (strcmp(result, "OK") == 0)
1294 return rettup;
1295 if (strcmp(result, "SKIP") == 0)
1296 return (HeapTuple) NULL;
1297
1298 /************************************************************
1299 * Otherwise, the return value should be a column name/value list
1300 * specifying the modified tuple to return.
1301 ************************************************************/
1302 if (Tcl_ListObjGetElements(interp, Tcl_GetObjResult(interp),
1303 &result_Objc, &result_Objv) != TCL_OK)
1304 ereport(ERROR,
1305 (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
1306 errmsg("could not parse trigger return value: %s",
1307 utf_u2e(Tcl_GetStringResult(interp)))));
1308
1309 /* Convert function result to tuple */
1310 rettup = pltcl_build_tuple_result(interp, result_Objv, result_Objc,
1311 call_state);
1312
1313 return rettup;
1314}

References Assert, compile_pltcl_function(), DatumGetCString(), DirectFunctionCall1, elog, ereport, errcode(), errmsg, ERROR, fb(), pltcl_proc_desc::fn_refcount, i, pltcl_proc_desc::internal_proname, pltcl_interp_desc::interp, pltcl_proc_desc::interp_desc, NameStr, TupleDescData::natts, ObjectIdGetDatum(), oidout(), pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PG_USED_FOR_ASSERTS_ONLY, pltcl_build_tuple_argument(), pltcl_build_tuple_result(), RelationData::rd_id, RelationGetDescr, RelationGetRelid, result, SPI_connect(), SPI_finish(), SPI_getnspname(), SPI_getrelname(), SPI_OK_FINISH, SPI_register_trigger_data(), TriggerData::tg_event, TriggerData::tg_newtuple, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, Trigger::tgargs, Trigger::tgname, Trigger::tgnargs, throw_tcl_error(), TRIGGER_FIRED_AFTER, TRIGGER_FIRED_BEFORE, TRIGGER_FIRED_BY_DELETE, TRIGGER_FIRED_BY_INSERT, TRIGGER_FIRED_BY_TRUNCATE, TRIGGER_FIRED_BY_UPDATE, TRIGGER_FIRED_FOR_ROW, TRIGGER_FIRED_FOR_STATEMENT, TRIGGER_FIRED_INSTEAD, TupleDescAttr(), pltcl_proc_desc::user_proname, utf_e2u(), and utf_u2e().

Referenced by pltcl_handler().

◆ pltcl_WaitForEvent()

static int pltcl_WaitForEvent ( CONST86 Tcl_Time *  timePtr)
static

Definition at line 395 of file pltcl.c.

396{
397 return 0;
398}

Referenced by _PG_init().

◆ pltclu_call_handler()

Datum pltclu_call_handler ( PG_FUNCTION_ARGS  )

Definition at line 718 of file pltcl.c.

719{
720 return pltcl_handler(fcinfo, false);
721}

References pltcl_handler().

◆ start_proc_error_callback()

static void start_proc_error_callback ( void *  arg)
static

Definition at line 686 of file pltcl.c.

687{
688 const char *gucname = (const char *) arg;
689
690 /* translator: %s is "pltcl.start_proc" or "pltclu.start_proc" */
691 errcontext("processing %s parameter", gucname);
692}

References arg, and errcontext.

Referenced by call_pltcl_start_proc().

◆ throw_tcl_error()

static void throw_tcl_error ( Tcl_Interp *  interp,
const char *  proname 
)
static

Definition at line 1374 of file pltcl.c.

1375{
1376 /*
1377 * Caution is needed here because Tcl_GetVar could overwrite the
1378 * interpreter result (even though it's not really supposed to), and we
1379 * can't control the order of evaluation of ereport arguments. Hence, make
1380 * real sure we have our own copy of the result string before invoking
1381 * Tcl_GetVar.
1382 */
1383 char *emsg;
1384 char *econtext;
1385 int emsglen;
1386
1387 emsg = pstrdup(utf_u2e(Tcl_GetStringResult(interp)));
1388 econtext = utf_u2e(Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY));
1389
1390 /*
1391 * Typically, the first line of errorInfo matches the primary error
1392 * message (the interpreter result); don't print that twice if so.
1393 */
1394 emsglen = strlen(emsg);
1395 if (strncmp(emsg, econtext, emsglen) == 0 &&
1396 econtext[emsglen] == '\n')
1397 econtext += emsglen + 1;
1398
1399 /* Tcl likes to prefix the next line with some spaces, too */
1400 while (*econtext == ' ')
1401 econtext++;
1402
1403 /* Note: proname will already contain quoting if any is needed */
1404 ereport(ERROR,
1405 (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
1406 errmsg("%s", emsg),
1407 errcontext("%s\nin PL/Tcl function %s",
1408 econtext, proname)));
1409}

References ereport, errcode(), errcontext, errmsg, ERROR, fb(), proname, pstrdup(), and utf_u2e().

Referenced by pltcl_event_trigger_handler(), pltcl_func_handler(), and pltcl_trigger_handler().

◆ utf_e2u()

static char * utf_e2u ( const char *  src)
inlinestatic

Definition at line 89 of file pltcl.c.

90{
91 return pg_server_to_any(src, strlen(src), PG_UTF8);
92}

References fb(), pg_server_to_any(), and PG_UTF8.

Referenced by pltcl_event_trigger_handler(), and pltcl_trigger_handler().

◆ utf_u2e()

static char * utf_u2e ( const char *  src)
inlinestatic

Definition at line 83 of file pltcl.c.

84{
85 return pg_any_to_server(src, strlen(src), PG_UTF8);
86}

References fb(), pg_any_to_server(), and PG_UTF8.

Referenced by compile_pltcl_function(), pltcl_build_tuple_result(), pltcl_func_handler(), pltcl_returnnext(), pltcl_trigger_handler(), and throw_tcl_error().

Variable Documentation

◆ exception_name_map

const TclExceptionNameMap exception_name_map[]
static
Initial value:
= {
{NULL, 0}
}

Definition at line 266 of file pltcl.c.

266 {
267#include "pltclerrcodes.h"
268 {NULL, 0}
269};

Referenced by pltcl_get_condition_name().

◆ pltcl_current_call_state

pltcl_call_state* pltcl_current_call_state = NULL
static

Definition at line 255 of file pltcl.c.

Referenced by pltcl_argisnull(), pltcl_handler(), pltcl_returnnext(), pltcl_returnnull(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), and pltcl_SPI_prepare().

◆ pltcl_hold_interp

Tcl_Interp* pltcl_hold_interp = NULL
static

Definition at line 250 of file pltcl.c.

Referenced by _PG_init(), and pltcl_init_interp().

◆ pltcl_interp_htab

HTAB* pltcl_interp_htab = NULL
static

Definition at line 251 of file pltcl.c.

Referenced by _PG_init(), and pltcl_fetch_interp().

◆ pltcl_pm_init_done

bool pltcl_pm_init_done = false
static

Definition at line 249 of file pltcl.c.

Referenced by _PG_init().

◆ pltcl_proc_htab

HTAB* pltcl_proc_htab = NULL
static

Definition at line 252 of file pltcl.c.

Referenced by _PG_init(), and compile_pltcl_function().

◆ pltcl_start_proc

char* pltcl_start_proc = NULL
static

Definition at line 247 of file pltcl.c.

Referenced by _PG_init(), and call_pltcl_start_proc().

◆ pltclu_start_proc

char* pltclu_start_proc = NULL
static

Definition at line 248 of file pltcl.c.

Referenced by _PG_init(), and call_pltcl_start_proc().