1 /*-------------------------------------------------------------------------
3 * plpgsql-9.1.h - Definitions for the PL/pgSQL
6 * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
11 * src/pl/plpgsql/src/plpgsql.h
13 *-------------------------------------------------------------------------
21 #include "access/xact.h"
23 #include "commands/trigger.h"
24 #include "executor/spi.h"
25 #include "lib/stringinfo.h"
26 #include "nodes/bitmapset.h"
27 #include "utils/tuplestore.h"
29 /**********************************************************************
31 **********************************************************************/
33 /* define our text domain for translations */
35 #define TEXTDOMAIN PG_TEXTDOMAIN("plpgsql")
38 #define _(x) dgettext(TEXTDOMAIN, x)
41 * Compiler's namespace item types
53 * Datum array node types
61 PLPGSQL_DTYPE_RECFIELD,
62 PLPGSQL_DTYPE_ARRAYELEM,
67 * Variants distinguished in PLpgSQL_type structs
72 PLPGSQL_TTYPE_SCALAR, /* scalar types and domains */
73 PLPGSQL_TTYPE_ROW, /* composite types */
74 PLPGSQL_TTYPE_REC, /* RECORD pseudotype */
75 PLPGSQL_TTYPE_PSEUDO /* other pseudotypes */
79 * Execution tree node types
82 enum PLpgSQL_stmt_types
93 PLPGSQL_STMT_FOREACH_A,
96 PLPGSQL_STMT_RETURN_NEXT,
97 PLPGSQL_STMT_RETURN_QUERY,
100 PLPGSQL_STMT_DYNEXECUTE,
101 PLPGSQL_STMT_DYNFORS,
102 PLPGSQL_STMT_GETDIAG,
111 * Execution node return codes
123 * GET DIAGNOSTICS system attrs
128 PLPGSQL_GETDIAG_ROW_COUNT,
129 PLPGSQL_GETDIAG_RESULT_OID
133 * RAISE statement options
138 PLPGSQL_RAISEOPTION_ERRCODE,
139 PLPGSQL_RAISEOPTION_MESSAGE,
140 PLPGSQL_RAISEOPTION_DETAIL,
141 PLPGSQL_RAISEOPTION_HINT
145 * Behavioral modes for plpgsql variable resolution
150 PLPGSQL_RESOLVE_ERROR, /* throw error if ambiguous */
151 PLPGSQL_RESOLVE_VARIABLE, /* prefer plpgsql var to table column */
152 PLPGSQL_RESOLVE_COLUMN /* prefer table column to plpgsql var */
153 } PLpgSQL_resolve_option;
156 /**********************************************************************
157 * Node and structure definitions
158 **********************************************************************/
162 { /* Postgres data type */
163 char *typname; /* (simple) name of the type */
164 Oid typoid; /* OID of the data type */
165 int ttype; /* PLPGSQL_TTYPE_ code */
166 int16 typlen; /* stuff copied from its pg_type entry */
170 Oid collation; /* from pg_type, but can be overridden */
171 FmgrInfo typinput; /* lookup info for typinput function */
172 int32 atttypmod; /* typmod (taken from someplace else) */
177 * PLpgSQL_datum is the common supertype for PLpgSQL_expr, PLpgSQL_var,
178 * PLpgSQL_row, PLpgSQL_rec, PLpgSQL_recfield, and PLpgSQL_arrayelem
181 { /* Generic datum array item */
187 * The variants PLpgSQL_var, PLpgSQL_row, and PLpgSQL_rec share these
191 { /* Scalar or composite variable */
198 typedef struct PLpgSQL_expr
199 { /* SQL Query to plan and execute */
204 Bitmapset *paramnos; /* all dnos referenced by this query */
206 /* function containing this expr (not set until we first parse query) */
207 struct PLpgSQL_function *func;
209 /* namespace chain visible to this expr */
210 struct PLpgSQL_nsitem *ns;
212 /* fields for "simple expression" fast-path execution: */
213 Expr *expr_simple_expr; /* NULL means not a simple expr */
214 int expr_simple_generation; /* plancache generation we checked */
215 Oid expr_simple_type; /* result type Oid, if simple */
218 * if expr is simple AND prepared in current transaction,
219 * expr_simple_state and expr_simple_in_use are valid. Test validity by
220 * seeing if expr_simple_lxid matches current LXID. (If not,
221 * expr_simple_state probably points at garbage!)
223 ExprState *expr_simple_state; /* eval tree for expr_simple_expr */
224 bool expr_simple_in_use; /* true if eval tree is active */
225 LocalTransactionId expr_simple_lxid;
230 { /* Scalar variable */
236 PLpgSQL_type *datatype;
239 PLpgSQL_expr *default_val;
240 PLpgSQL_expr *cursor_explicit_expr;
241 int cursor_explicit_argrow;
257 TupleDesc rowtupdesc;
260 * Note: TupleDesc is only set up for named rowtypes, else it is NULL.
262 * Note: if the underlying rowtype contains a dropped column, the
263 * corresponding fieldnames[] entry will be NULL, and there is no
264 * corresponding var (varnos[] will be -1).
273 { /* Record variable (non-fixed structure) */
287 { /* Field in record */
291 int recparentno; /* dno of parent record */
296 { /* Element of array variable */
299 PLpgSQL_expr *subscript;
300 int arrayparentno; /* dno of parent array variable */
304 typedef struct PLpgSQL_nsitem
305 { /* Item in the compilers namespace tree */
308 struct PLpgSQL_nsitem *prev;
309 char name[1]; /* actually, as long as needed */
314 { /* Generic execution node */
320 typedef struct PLpgSQL_condition
321 { /* One EXCEPTION condition name */
322 int sqlerrstate; /* SQLSTATE code */
323 char *condname; /* condition name (for debugging) */
324 struct PLpgSQL_condition *next;
331 List *exc_list; /* List of WHEN clauses */
332 } PLpgSQL_exception_block;
335 { /* One EXCEPTION ... WHEN clause */
337 PLpgSQL_condition *conditions;
338 List *action; /* List of statements */
343 { /* Block of statements */
347 List *body; /* List of statements */
350 PLpgSQL_exception_block *exceptions;
351 } PLpgSQL_stmt_block;
355 { /* Assign statement */
360 } PLpgSQL_stmt_assign;
363 { /* PERFORM statement */
367 } PLpgSQL_stmt_perform;
370 { /* Get Diagnostics item */
371 int kind; /* id for diagnostic value desired */
372 int target; /* where to assign it */
376 { /* Get Diagnostics statement */
379 List *diag_items; /* List of PLpgSQL_diag_item */
380 } PLpgSQL_stmt_getdiag;
388 List *true_body; /* List of statements */
389 List *false_body; /* List of statements */
393 typedef struct /* CASE statement */
397 PLpgSQL_expr *t_expr; /* test expression, or NULL if none */
398 int t_varno; /* var to store test expression value into */
399 List *case_when_list; /* List of PLpgSQL_case_when structs */
400 bool have_else; /* flag needed because list could be empty */
401 List *else_stmts; /* List of statements */
404 typedef struct /* one arm of CASE statement */
407 PLpgSQL_expr *expr; /* boolean expression for this case */
408 List *stmts; /* List of statements */
413 { /* Unconditional LOOP statement */
417 List *body; /* List of statements */
422 { /* WHILE cond LOOP statement */
427 List *body; /* List of statements */
428 } PLpgSQL_stmt_while;
432 { /* FOR statement with integer loopvar */
439 PLpgSQL_expr *step; /* NULL means default (ie, BY 1) */
441 List *body; /* List of statements */
446 * PLpgSQL_stmt_forq represents a FOR statement running over a SQL query.
447 * It is the common supertype of PLpgSQL_stmt_fors, PLpgSQL_stmt_forc
448 * and PLpgSQL_dynfors.
457 List *body; /* List of statements */
461 { /* FOR statement running over SELECT */
467 List *body; /* List of statements */
468 /* end of fields that must match PLpgSQL_stmt_forq */
473 { /* FOR statement running over cursor */
479 List *body; /* List of statements */
480 /* end of fields that must match PLpgSQL_stmt_forq */
482 PLpgSQL_expr *argquery; /* cursor arguments if any */
486 { /* FOR statement running over EXECUTE */
492 List *body; /* List of statements */
493 /* end of fields that must match PLpgSQL_stmt_forq */
495 List *params; /* USING expressions */
496 } PLpgSQL_stmt_dynfors;
500 { /* FOREACH item in array loop */
504 int varno; /* loop target variable */
505 int slice; /* slice dimension, or 0 */
506 PLpgSQL_expr *expr; /* array expression */
507 List *body; /* List of statements */
508 } PLpgSQL_stmt_foreach_a;
512 { /* OPEN a curvar */
517 PLpgSQL_row *returntype;
518 PLpgSQL_expr *argquery;
520 PLpgSQL_expr *dynquery;
521 List *params; /* USING expressions */
526 { /* FETCH or MOVE statement */
529 PLpgSQL_rec *rec; /* target, as record or row */
531 int curvar; /* cursor variable to fetch from */
532 FetchDirection direction; /* fetch direction */
533 long how_many; /* count, if constant (expr is NULL) */
534 PLpgSQL_expr *expr; /* count, if expression */
535 bool is_move; /* is this a fetch or move? */
536 bool returns_multiple_rows; /* can return more than one row? */
537 } PLpgSQL_stmt_fetch;
545 } PLpgSQL_stmt_close;
549 { /* EXIT or CONTINUE statement */
552 bool is_exit; /* Is this an exit or a continue? */
553 char *label; /* NULL if it's an unlabelled EXIT/CONTINUE */
559 { /* RETURN statement */
564 } PLpgSQL_stmt_return;
567 { /* RETURN NEXT statement */
572 } PLpgSQL_stmt_return_next;
575 { /* RETURN QUERY statement */
578 PLpgSQL_expr *query; /* if static query */
579 PLpgSQL_expr *dynquery; /* if dynamic query (RETURN QUERY EXECUTE) */
580 List *params; /* USING arguments for dynamic query */
581 } PLpgSQL_stmt_return_query;
584 { /* RAISE statement */
588 char *condname; /* condition name, SQLSTATE, or NULL */
589 char *message; /* old-style message format literal, or NULL */
590 List *params; /* list of expressions for old-style message */
591 List *options; /* list of PLpgSQL_raise_option */
592 } PLpgSQL_stmt_raise;
595 { /* RAISE statement option */
598 } PLpgSQL_raise_option;
602 { /* Generic SQL statement to execute */
605 PLpgSQL_expr *sqlstmt;
606 bool mod_stmt; /* is the stmt INSERT/UPDATE/DELETE? */
607 /* note: mod_stmt is set when we plan the query */
608 bool into; /* INTO supplied? */
609 bool strict; /* INTO STRICT flag */
610 PLpgSQL_rec *rec; /* INTO target, if record */
611 PLpgSQL_row *row; /* INTO target, if row */
612 } PLpgSQL_stmt_execsql;
616 { /* Dynamic SQL string to execute */
619 PLpgSQL_expr *query; /* string expression */
620 bool into; /* INTO supplied? */
621 bool strict; /* INTO STRICT flag */
622 PLpgSQL_rec *rec; /* INTO target, if record */
623 PLpgSQL_row *row; /* INTO target, if row */
624 List *params; /* USING expressions */
625 } PLpgSQL_stmt_dynexecute;
628 typedef struct PLpgSQL_func_hashkey
629 { /* Hash lookup key for functions */
632 bool isTrigger; /* true if called as a trigger */
634 /* be careful that pad bytes in this struct get zeroed! */
637 * For a trigger function, the OID of the relation triggered on is part of
638 * the hash key --- we want to compile the trigger separately for each
639 * relation it is used with, in case the rowtype is different. Zero if
640 * not called as a trigger.
645 * We must include the input collation as part of the hash key too,
646 * because we have to generate different plans (with different Param
647 * collations) for different collation settings.
652 * We include actual argument types in the hash key to support polymorphic
653 * PLpgSQL functions. Be careful that extra positions are zeroed!
655 Oid argtypes[FUNC_MAX_ARGS];
656 } PLpgSQL_func_hashkey;
659 typedef struct PLpgSQL_function
660 { /* Complete compiled function */
663 TransactionId fn_xmin;
664 ItemPointerData fn_tid;
666 Oid fn_input_collation;
667 PLpgSQL_func_hashkey *fn_hashkey; /* back-link to hashtable key */
668 MemoryContext fn_cxt;
673 FmgrInfo fn_retinput;
674 Oid fn_rettypioparam;
680 int fn_argvarnos[FUNC_MAX_ARGS];
690 int tg_relname_varno;
691 int tg_table_name_varno;
692 int tg_table_schema_varno;
696 PLpgSQL_resolve_option resolve_option;
699 PLpgSQL_datum **datums;
700 PLpgSQL_stmt_block *action;
702 /* these fields change when the function is used */
703 struct PLpgSQL_execstate *cur_estate;
704 unsigned long use_count;
708 typedef struct PLpgSQL_execstate
709 { /* Runtime execution data */
710 PLpgSQL_function *func; /* function being executed */
714 Oid rettype; /* type of current retval */
716 Oid fn_rettype; /* info about declared function rettype */
722 TupleDesc rettupdesc;
723 char *exitlabel; /* the "target" label of the current EXIT or
724 * CONTINUE stmt, if any */
725 ErrorData *cur_error; /* current exception handler's error */
727 Tuplestorestate *tuple_store; /* SRFs accumulate results here */
728 MemoryContext tuple_store_cxt;
729 ResourceOwner tuple_store_owner;
734 PLpgSQL_datum **datums;
736 /* temporary state for results from evaluation of query or expr */
737 SPITupleTable *eval_tuptable;
738 uint32 eval_processed;
740 ExprContext *eval_econtext; /* for executing simple expressions */
741 PLpgSQL_expr *cur_expr; /* current query/expr being evaluated */
743 /* status information for error context reporting */
744 PLpgSQL_stmt *err_stmt; /* current stmt */
745 const char *err_text; /* additional state info */
747 void *plugin_info; /* reserved for use by optional plugin */
752 * A PLpgSQL_plugin structure represents an instrumentation plugin.
753 * To instrument PL/pgSQL, a plugin library must access the rendezvous
754 * variable "PLpgSQL_plugin" and set it to point to a PLpgSQL_plugin struct.
755 * Typically the struct could just be static data in the plugin library.
756 * We expect that a plugin would do this at library load time (_PG_init()).
757 * It must also be careful to set the rendezvous variable back to NULL
758 * if it is unloaded (_PG_fini()).
760 * This structure is basically a collection of function pointers --- at
761 * various interesting points in pl_exec.c, we call these functions
762 * (if the pointers are non-NULL) to give the plugin a chance to watch
765 * func_setup is called when we start a function, before we've initialized
766 * the local variables defined by the function.
768 * func_beg is called when we start a function, after we've initialized
769 * the local variables.
771 * func_end is called at the end of a function.
773 * stmt_beg and stmt_end are called before and after (respectively) each
776 * Also, immediately before any call to func_setup, PL/pgSQL fills in the
777 * error_callback and assign_expr fields with pointers to its own
778 * plpgsql_exec_error_callback and exec_assign_expr functions. This is
779 * a somewhat ad-hoc expedient to simplify life for debugger plugins.
784 /* Function pointers set up by the plugin */
785 void (*func_setup) (PLpgSQL_execstate *estate, PLpgSQL_function *func);
786 void (*func_beg) (PLpgSQL_execstate *estate, PLpgSQL_function *func);
787 void (*func_end) (PLpgSQL_execstate *estate, PLpgSQL_function *func);
788 void (*stmt_beg) (PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt);
789 void (*stmt_end) (PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt);
791 /* Function pointers set by PL/pgSQL itself */
792 void (*error_callback) (void *arg);
793 void (*assign_expr) (PLpgSQL_execstate *estate, PLpgSQL_datum *target,
798 /* Struct types used during parsing */
802 char *ident; /* palloc'd converted identifier */
803 bool quoted; /* Was it double-quoted? */
808 List *idents; /* composite identifiers (list of String) */
813 PLpgSQL_datum *datum; /* referenced variable */
814 char *ident; /* valid if simple name */
816 List *idents; /* valid if composite name */
819 /**********************************************************************
820 * Global variable declarations
821 **********************************************************************/
825 IDENTIFIER_LOOKUP_NORMAL, /* normal processing of var names */
826 IDENTIFIER_LOOKUP_DECLARE, /* In DECLARE --- don't look up names */
827 IDENTIFIER_LOOKUP_EXPR /* In SQL expression --- special case */
830 extern IdentifierLookup plpgsql_IdentifierLookup;
832 extern int plpgsql_variable_conflict;
834 extern bool plpgsql_check_syntax;
835 extern bool plpgsql_DumpExecTree;
837 extern PLpgSQL_stmt_block *plpgsql_parse_result;
839 extern int plpgsql_nDatums;
840 extern PLpgSQL_datum **plpgsql_Datums;
842 extern char *plpgsql_error_funcname;
844 extern PLpgSQL_function *plpgsql_curr_compile;
845 extern MemoryContext compile_tmp_cxt;
847 extern PLpgSQL_plugin **plugin_ptr;
849 /**********************************************************************
850 * Function declarations
851 **********************************************************************/
854 * Functions in pl_comp.c
857 extern PLpgSQL_function *plpgsql_compile(FunctionCallInfo fcinfo,
859 extern PLpgSQL_function *plpgsql_compile_inline(char *proc_source);
860 extern void plpgsql_parser_setup(struct ParseState *pstate,
862 extern bool plpgsql_parse_word(char *word1, const char *yytxt,
863 PLwdatum *wdatum, PLword *word);
864 extern bool plpgsql_parse_dblword(char *word1, char *word2,
865 PLwdatum *wdatum, PLcword *cword);
866 extern bool plpgsql_parse_tripword(char *word1, char *word2, char *word3,
867 PLwdatum *wdatum, PLcword *cword);
868 extern PLpgSQL_type *plpgsql_parse_wordtype(char *ident);
869 extern PLpgSQL_type *plpgsql_parse_cwordtype(List *idents);
870 extern PLpgSQL_type *plpgsql_parse_wordrowtype(char *ident);
871 extern PLpgSQL_type *plpgsql_parse_cwordrowtype(List *idents);
872 extern PLpgSQL_type *plpgsql_build_datatype(Oid typeOid, int32 typmod,
874 extern PLpgSQL_variable *plpgsql_build_variable(const char *refname, int lineno,
877 extern PLpgSQL_rec *plpgsql_build_record(const char *refname, int lineno,
879 extern int plpgsql_recognize_err_condition(const char *condname,
880 bool allow_sqlstate);
881 extern PLpgSQL_condition *plpgsql_parse_err_condition(char *condname);
882 extern void plpgsql_adddatum(PLpgSQL_datum *new);
883 extern int plpgsql_add_initdatums(int **varnos);
884 extern void plpgsql_HashTableInit(void);
887 * Functions in pl_handler.c
890 extern void _PG_init(void);
891 extern Datum plpgsql_call_handler(PG_FUNCTION_ARGS);
892 extern Datum plpgsql_inline_handler(PG_FUNCTION_ARGS);
893 extern Datum plpgsql_validator(PG_FUNCTION_ARGS);
896 * Functions in pl_exec.c
899 extern Datum plpgsql_exec_function(PLpgSQL_function *func,
900 FunctionCallInfo fcinfo);
901 extern HeapTuple plpgsql_exec_trigger(PLpgSQL_function *func,
902 TriggerData *trigdata);
903 extern void plpgsql_xact_cb(XactEvent event, void *arg);
904 extern void plpgsql_subxact_cb(SubXactEvent event, SubTransactionId mySubid,
905 SubTransactionId parentSubid, void *arg);
906 extern Oid exec_get_datum_type(PLpgSQL_execstate *estate,
907 PLpgSQL_datum *datum);
908 extern void exec_get_datum_type_info(PLpgSQL_execstate *estate,
909 PLpgSQL_datum *datum,
910 Oid *typeid, int32 *typmod, Oid *collation);
913 * Functions for namespace handling in pl_funcs.c
916 extern void plpgsql_ns_init(void);
917 extern void plpgsql_ns_push(const char *label);
918 extern void plpgsql_ns_pop(void);
919 extern PLpgSQL_nsitem *plpgsql_ns_top(void);
920 extern void plpgsql_ns_additem(int itemtype, int itemno, const char *name);
921 extern PLpgSQL_nsitem *plpgsql_ns_lookup(PLpgSQL_nsitem *ns_cur, bool localmode,
922 const char *name1, const char *name2,
923 const char *name3, int *names_used);
924 extern PLpgSQL_nsitem *plpgsql_ns_lookup_label(PLpgSQL_nsitem *ns_cur,
928 * Other functions in pl_funcs.c
931 extern const char *plpgsql_stmt_typename(PLpgSQL_stmt *stmt);
932 extern void plpgsql_free_function_memory(PLpgSQL_function *func);
933 extern void plpgsql_dumptree(PLpgSQL_function *func);
936 * Scanner functions in pl_scanner.c
939 extern int plpgsql_base_yylex(void);
940 extern int plpgsql_yylex(void);
941 extern void plpgsql_push_back_token(int token);
942 extern void plpgsql_append_source_text(StringInfo buf,
943 int startlocation, int endlocation);
944 extern int plpgsql_scanner_errposition(int location);
945 extern void plpgsql_yyerror(const char *message);
946 extern int plpgsql_location_to_lineno(int location);
947 extern int plpgsql_latest_lineno(void);
948 extern void plpgsql_scanner_init(const char *str);
949 extern void plpgsql_scanner_finish(void);
955 extern int plpgsql_yyparse(void);
957 #endif /* PLPGSQL_H */