/*------------------------------------------------------------------------- * * plpgsql.h - Definitions for the PL/pgSQL * procedural language * * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION * src/pl/plpgsql/src/plpgsql.h * *------------------------------------------------------------------------- */ #ifndef PLPGSQL_H #define PLPGSQL_H #include "access/xact.h" #include "commands/event_trigger.h" #include "commands/trigger.h" #include "executor/spi.h" #include "utils/expandedrecord.h" #include "utils/typcache.h" /********************************************************************** * Definitions **********************************************************************/ /* define our text domain for translations */ #undef TEXTDOMAIN #define TEXTDOMAIN PG_TEXTDOMAIN("plpgsql") #undef _ #define _(x) dgettext(TEXTDOMAIN, x) /* * Compiler's namespace item types */ typedef enum PLpgSQL_nsitem_type { PLPGSQL_NSTYPE_LABEL, /* block label */ PLPGSQL_NSTYPE_VAR, /* scalar variable */ PLPGSQL_NSTYPE_REC /* composite variable */ } PLpgSQL_nsitem_type; /* * A PLPGSQL_NSTYPE_LABEL stack entry must be one of these types */ typedef enum PLpgSQL_label_type { PLPGSQL_LABEL_BLOCK, /* DECLARE/BEGIN block */ PLPGSQL_LABEL_LOOP, /* looping construct */ PLPGSQL_LABEL_OTHER /* anything else */ } PLpgSQL_label_type; /* * Datum array node types */ typedef enum PLpgSQL_datum_type { PLPGSQL_DTYPE_VAR, PLPGSQL_DTYPE_ROW, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_RECFIELD, PLPGSQL_DTYPE_PROMISE } PLpgSQL_datum_type; /* * DTYPE_PROMISE datums have these possible ways of computing the promise */ typedef enum PLpgSQL_promise_type { PLPGSQL_PROMISE_NONE = 0, /* not a promise, or promise satisfied */ PLPGSQL_PROMISE_TG_NAME, PLPGSQL_PROMISE_TG_WHEN, PLPGSQL_PROMISE_TG_LEVEL, PLPGSQL_PROMISE_TG_OP, PLPGSQL_PROMISE_TG_RELID, PLPGSQL_PROMISE_TG_TABLE_NAME, PLPGSQL_PROMISE_TG_TABLE_SCHEMA, PLPGSQL_PROMISE_TG_NARGS, PLPGSQL_PROMISE_TG_ARGV, PLPGSQL_PROMISE_TG_EVENT, PLPGSQL_PROMISE_TG_TAG } PLpgSQL_promise_type; /* * Variants distinguished in PLpgSQL_type structs */ typedef enum PLpgSQL_type_type { PLPGSQL_TTYPE_SCALAR, /* scalar types and domains */ PLPGSQL_TTYPE_REC, /* composite types, including RECORD */ PLPGSQL_TTYPE_PSEUDO /* pseudotypes */ } PLpgSQL_type_type; /* * Execution tree node types */ typedef enum PLpgSQL_stmt_type { PLPGSQL_STMT_BLOCK, PLPGSQL_STMT_ASSIGN, PLPGSQL_STMT_IF, PLPGSQL_STMT_CASE, PLPGSQL_STMT_LOOP, PLPGSQL_STMT_WHILE, PLPGSQL_STMT_FORI, PLPGSQL_STMT_FORS, PLPGSQL_STMT_FORC, PLPGSQL_STMT_FOREACH_A, PLPGSQL_STMT_EXIT, PLPGSQL_STMT_RETURN, PLPGSQL_STMT_RETURN_NEXT, PLPGSQL_STMT_RETURN_QUERY, PLPGSQL_STMT_RAISE, PLPGSQL_STMT_ASSERT, PLPGSQL_STMT_EXECSQL, PLPGSQL_STMT_DYNEXECUTE, PLPGSQL_STMT_DYNFORS, PLPGSQL_STMT_GETDIAG, PLPGSQL_STMT_OPEN, PLPGSQL_STMT_FETCH, PLPGSQL_STMT_CLOSE, PLPGSQL_STMT_PERFORM, PLPGSQL_STMT_CALL, PLPGSQL_STMT_COMMIT, PLPGSQL_STMT_ROLLBACK } PLpgSQL_stmt_type; /* * Execution node return codes */ enum { PLPGSQL_RC_OK, PLPGSQL_RC_EXIT, PLPGSQL_RC_RETURN, PLPGSQL_RC_CONTINUE }; /* * GET DIAGNOSTICS information items */ typedef enum PLpgSQL_getdiag_kind { PLPGSQL_GETDIAG_ROW_COUNT, PLPGSQL_GETDIAG_ROUTINE_OID, PLPGSQL_GETDIAG_CONTEXT, PLPGSQL_GETDIAG_ERROR_CONTEXT, PLPGSQL_GETDIAG_ERROR_DETAIL, PLPGSQL_GETDIAG_ERROR_HINT, PLPGSQL_GETDIAG_RETURNED_SQLSTATE, PLPGSQL_GETDIAG_COLUMN_NAME, PLPGSQL_GETDIAG_CONSTRAINT_NAME, PLPGSQL_GETDIAG_DATATYPE_NAME, PLPGSQL_GETDIAG_MESSAGE_TEXT, PLPGSQL_GETDIAG_TABLE_NAME, PLPGSQL_GETDIAG_SCHEMA_NAME } PLpgSQL_getdiag_kind; /* * RAISE statement options */ typedef enum PLpgSQL_raise_option_type { PLPGSQL_RAISEOPTION_ERRCODE, PLPGSQL_RAISEOPTION_MESSAGE, PLPGSQL_RAISEOPTION_DETAIL, PLPGSQL_RAISEOPTION_HINT, PLPGSQL_RAISEOPTION_COLUMN, PLPGSQL_RAISEOPTION_CONSTRAINT, PLPGSQL_RAISEOPTION_DATATYPE, PLPGSQL_RAISEOPTION_TABLE, PLPGSQL_RAISEOPTION_SCHEMA } PLpgSQL_raise_option_type; /* * Behavioral modes for plpgsql variable resolution */ typedef enum PLpgSQL_resolve_option { PLPGSQL_RESOLVE_ERROR, /* throw error if ambiguous */ PLPGSQL_RESOLVE_VARIABLE, /* prefer plpgsql var to table column */ PLPGSQL_RESOLVE_COLUMN /* prefer table column to plpgsql var */ } PLpgSQL_resolve_option; /********************************************************************** * Node and structure definitions **********************************************************************/ /* * Postgres data type */ typedef struct PLpgSQL_type { char *typname; /* (simple) name of the type */ Oid typoid; /* OID of the data type */ PLpgSQL_type_type ttype; /* PLPGSQL_TTYPE_ code */ int16 typlen; /* stuff copied from its pg_type entry */ bool typbyval; char typtype; Oid collation; /* from pg_type, but can be overridden */ bool typisarray; /* is "true" array, or domain over one */ int32 atttypmod; /* typmod (taken from someplace else) */ /* Remaining fields are used only for named composite types (not RECORD) */ TypeName *origtypname; /* type name as written by user */ TypeCacheEntry *tcache; /* typcache entry for composite type */ uint64 tupdesc_id; /* last-seen tupdesc identifier */ } PLpgSQL_type; /* * SQL Query to plan and execute */ typedef struct PLpgSQL_expr { char *query; /* query string, verbatim from function body */ RawParseMode parseMode; /* raw_parser() mode to use */ SPIPlanPtr plan; /* plan, or NULL if not made yet */ Bitmapset *paramnos; /* all dnos referenced by this query */ /* function containing this expr (not set until we first parse query) */ struct PLpgSQL_function *func; /* namespace chain visible to this expr */ struct PLpgSQL_nsitem *ns; /* fields for "simple expression" fast-path execution: */ Expr *expr_simple_expr; /* NULL means not a simple expr */ Oid expr_simple_type; /* result type Oid, if simple */ int32 expr_simple_typmod; /* result typmod, if simple */ bool expr_simple_mutable; /* true if simple expr is mutable */ /* * These fields are used to optimize assignments to expanded-datum * variables. If this expression is the source of an assignment to a * simple variable, target_param holds that variable's dno; else it's -1. * If we match a Param within expr_simple_expr to such a variable, that * Param's address is stored in expr_rw_param; then expression code * generation will allow the value for that Param to be passed read/write. */ int target_param; /* dno of assign target, or -1 if none */ Param *expr_rw_param; /* read/write Param within expr, if any */ /* * If the expression was ever determined to be simple, we remember its * CachedPlanSource and CachedPlan here. If expr_simple_plan_lxid matches * current LXID, then we hold a refcount on expr_simple_plan in the * current transaction. Otherwise we need to get one before re-using it. */ CachedPlanSource *expr_simple_plansource; /* extracted from "plan" */ CachedPlan *expr_simple_plan; /* extracted from "plan" */ LocalTransactionId expr_simple_plan_lxid; /* * if expr is simple AND prepared in current transaction, * expr_simple_state and expr_simple_in_use are valid. Test validity by * seeing if expr_simple_lxid matches current LXID. (If not, * expr_simple_state probably points at garbage!) */ ExprState *expr_simple_state; /* eval tree for expr_simple_expr */ bool expr_simple_in_use; /* true if eval tree is active */ LocalTransactionId expr_simple_lxid; } PLpgSQL_expr; /* * Generic datum array item * * PLpgSQL_datum is the common supertype for PLpgSQL_var, PLpgSQL_row, * PLpgSQL_rec, and PLpgSQL_recfield. */ typedef struct PLpgSQL_datum { PLpgSQL_datum_type dtype; int dno; } PLpgSQL_datum; /* * Scalar or composite variable * * The variants PLpgSQL_var, PLpgSQL_row, and PLpgSQL_rec share these * fields. */ typedef struct PLpgSQL_variable { PLpgSQL_datum_type dtype; int dno; char *refname; int lineno; bool isconst; bool notnull; PLpgSQL_expr *default_val; } PLpgSQL_variable; /* * Scalar variable * * DTYPE_VAR and DTYPE_PROMISE datums both use this struct type. * A PROMISE datum works exactly like a VAR datum for most purposes, * but if it is read without having previously been assigned to, then * a special "promised" value is computed and assigned to the datum * before the read is performed. This technique avoids the overhead of * computing the variable's value in cases where we expect that many * functions will never read it. */ typedef struct PLpgSQL_var { PLpgSQL_datum_type dtype; int dno; char *refname; int lineno; bool isconst; bool notnull; PLpgSQL_expr *default_val; /* end of PLpgSQL_variable fields */ PLpgSQL_type *datatype; /* * Variables declared as CURSOR FOR are mostly like ordinary * scalar variables of type refcursor, but they have these additional * properties: */ PLpgSQL_expr *cursor_explicit_expr; int cursor_explicit_argrow; int cursor_options; /* Fields below here can change at runtime */ Datum value; bool isnull; bool freeval; /* * The promise field records which "promised" value to assign if the * promise must be honored. If it's a normal variable, or the promise has * been fulfilled, this is PLPGSQL_PROMISE_NONE. */ PLpgSQL_promise_type promise; } PLpgSQL_var; /* * Row variable - this represents one or more variables that are listed in an * INTO clause, FOR-loop targetlist, cursor argument list, etc. We also use * a row to represent a function's OUT parameters when there's more than one. * * Note that there's no way to name the row as such from PL/pgSQL code, * so many functions don't need to support these. * * That also means that there's no real name for the row variable, so we * conventionally set refname to "(unnamed row)". We could leave it NULL, * but it's too convenient to be able to assume that refname is valid in * all variants of PLpgSQL_variable. * * isconst, notnull, and default_val are unsupported (and hence * always zero/null) for a row. The member variables of a row should have * been checked to be writable at compile time, so isconst is correctly set * to false. notnull and default_val aren't applicable. */ typedef struct PLpgSQL_row { PLpgSQL_datum_type dtype; int dno; char *refname; int lineno; bool isconst; bool notnull; PLpgSQL_expr *default_val; /* end of PLpgSQL_variable fields */ /* * rowtupdesc is only set up if we might need to convert the row into a * composite datum, which currently only happens for OUT parameters. * Otherwise it is NULL. */ TupleDesc rowtupdesc; int nfields; char **fieldnames; int *varnos; } PLpgSQL_row; /* * Record variable (any composite type, including RECORD) */ typedef struct PLpgSQL_rec { PLpgSQL_datum_type dtype; int dno; char *refname; int lineno; bool isconst; bool notnull; PLpgSQL_expr *default_val; /* end of PLpgSQL_variable fields */ /* * Note: for non-RECORD cases, we may from time to time re-look-up the * composite type, using datatype->origtypname. That can result in * changing rectypeid. */ PLpgSQL_type *datatype; /* can be NULL, if rectypeid is RECORDOID */ Oid rectypeid; /* declared type of variable */ /* RECFIELDs for this record are chained together for easy access */ int firstfield; /* dno of first RECFIELD, or -1 if none */ /* Fields below here can change at runtime */ /* We always store record variables as "expanded" records */ ExpandedRecordHeader *erh; } PLpgSQL_rec; /* * Field in record */ typedef struct PLpgSQL_recfield { PLpgSQL_datum_type dtype; int dno; /* end of PLpgSQL_datum fields */ char *fieldname; /* name of field */ int recparentno; /* dno of parent record */ int nextfield; /* dno of next child, or -1 if none */ uint64 rectupledescid; /* record's tupledesc ID as of last lookup */ ExpandedRecordFieldInfo finfo; /* field's attnum and type info */ /* if rectupledescid == INVALID_TUPLEDESC_IDENTIFIER, finfo isn't valid */ } PLpgSQL_recfield; /* * Item in the compilers namespace tree */ typedef struct PLpgSQL_nsitem { PLpgSQL_nsitem_type itemtype; /* * For labels, itemno is a value of enum PLpgSQL_label_type. For other * itemtypes, itemno is the associated PLpgSQL_datum's dno. */ int itemno; struct PLpgSQL_nsitem *prev; char name[FLEXIBLE_ARRAY_MEMBER]; /* nul-terminated string */ } PLpgSQL_nsitem; /* * Generic execution node */ typedef struct PLpgSQL_stmt { PLpgSQL_stmt_type cmd_type; int lineno; /* * Unique statement ID in this function (starting at 1; 0 is invalid/not * set). This can be used by a profiler as the index for an array of * per-statement metrics. */ unsigned int stmtid; } PLpgSQL_stmt; /* * One EXCEPTION condition name */ typedef struct PLpgSQL_condition { int sqlerrstate; /* SQLSTATE code */ char *condname; /* condition name (for debugging) */ struct PLpgSQL_condition *next; } PLpgSQL_condition; /* * EXCEPTION block */ typedef struct PLpgSQL_exception_block { int sqlstate_varno; int sqlerrm_varno; List *exc_list; /* List of WHEN clauses */ } PLpgSQL_exception_block; /* * One EXCEPTION ... WHEN clause */ typedef struct PLpgSQL_exception { int lineno; PLpgSQL_condition *conditions; List *action; /* List of statements */ } PLpgSQL_exception; /* * Block of statements */ typedef struct PLpgSQL_stmt_block { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; List *body; /* List of statements */ int n_initvars; /* Length of initvarnos[] */ int *initvarnos; /* dnos of variables declared in this block */ PLpgSQL_exception_block *exceptions; } PLpgSQL_stmt_block; /* * Assign statement */ typedef struct PLpgSQL_stmt_assign { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; int varno; PLpgSQL_expr *expr; } PLpgSQL_stmt_assign; /* * PERFORM statement */ typedef struct PLpgSQL_stmt_perform { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *expr; } PLpgSQL_stmt_perform; /* * CALL statement */ typedef struct PLpgSQL_stmt_call { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *expr; bool is_call; PLpgSQL_variable *target; } PLpgSQL_stmt_call; /* * COMMIT statement */ typedef struct PLpgSQL_stmt_commit { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; bool chain; } PLpgSQL_stmt_commit; /* * ROLLBACK statement */ typedef struct PLpgSQL_stmt_rollback { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; bool chain; } PLpgSQL_stmt_rollback; /* * GET DIAGNOSTICS item */ typedef struct PLpgSQL_diag_item { PLpgSQL_getdiag_kind kind; /* id for diagnostic value desired */ int target; /* where to assign it */ } PLpgSQL_diag_item; /* * GET DIAGNOSTICS statement */ typedef struct PLpgSQL_stmt_getdiag { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; bool is_stacked; /* STACKED or CURRENT diagnostics area? */ List *diag_items; /* List of PLpgSQL_diag_item */ } PLpgSQL_stmt_getdiag; /* * IF statement */ typedef struct PLpgSQL_stmt_if { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *cond; /* boolean expression for THEN */ List *then_body; /* List of statements */ List *elsif_list; /* List of PLpgSQL_if_elsif structs */ List *else_body; /* List of statements */ } PLpgSQL_stmt_if; /* * one ELSIF arm of IF statement */ typedef struct PLpgSQL_if_elsif { int lineno; PLpgSQL_expr *cond; /* boolean expression for this case */ List *stmts; /* List of statements */ } PLpgSQL_if_elsif; /* * CASE statement */ typedef struct PLpgSQL_stmt_case { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *t_expr; /* test expression, or NULL if none */ int t_varno; /* var to store test expression value into */ List *case_when_list; /* List of PLpgSQL_case_when structs */ bool have_else; /* flag needed because list could be empty */ List *else_stmts; /* List of statements */ } PLpgSQL_stmt_case; /* * one arm of CASE statement */ typedef struct PLpgSQL_case_when { int lineno; PLpgSQL_expr *expr; /* boolean expression for this case */ List *stmts; /* List of statements */ } PLpgSQL_case_when; /* * Unconditional LOOP statement */ typedef struct PLpgSQL_stmt_loop { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; List *body; /* List of statements */ } PLpgSQL_stmt_loop; /* * WHILE cond LOOP statement */ typedef struct PLpgSQL_stmt_while { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; PLpgSQL_expr *cond; List *body; /* List of statements */ } PLpgSQL_stmt_while; /* * FOR statement with integer loopvar */ typedef struct PLpgSQL_stmt_fori { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; PLpgSQL_var *var; PLpgSQL_expr *lower; PLpgSQL_expr *upper; PLpgSQL_expr *step; /* NULL means default (ie, BY 1) */ int reverse; List *body; /* List of statements */ } PLpgSQL_stmt_fori; /* * PLpgSQL_stmt_forq represents a FOR statement running over a SQL query. * It is the common supertype of PLpgSQL_stmt_fors, PLpgSQL_stmt_forc * and PLpgSQL_stmt_dynfors. */ typedef struct PLpgSQL_stmt_forq { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; PLpgSQL_variable *var; /* Loop variable (record or row) */ List *body; /* List of statements */ } PLpgSQL_stmt_forq; /* * FOR statement running over SELECT */ typedef struct PLpgSQL_stmt_fors { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; PLpgSQL_variable *var; /* Loop variable (record or row) */ List *body; /* List of statements */ /* end of fields that must match PLpgSQL_stmt_forq */ PLpgSQL_expr *query; } PLpgSQL_stmt_fors; /* * FOR statement running over cursor */ typedef struct PLpgSQL_stmt_forc { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; PLpgSQL_variable *var; /* Loop variable (record or row) */ List *body; /* List of statements */ /* end of fields that must match PLpgSQL_stmt_forq */ int curvar; PLpgSQL_expr *argquery; /* cursor arguments if any */ } PLpgSQL_stmt_forc; /* * FOR statement running over EXECUTE */ typedef struct PLpgSQL_stmt_dynfors { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; PLpgSQL_variable *var; /* Loop variable (record or row) */ List *body; /* List of statements */ /* end of fields that must match PLpgSQL_stmt_forq */ PLpgSQL_expr *query; List *params; /* USING expressions */ } PLpgSQL_stmt_dynfors; /* * FOREACH item in array loop */ typedef struct PLpgSQL_stmt_foreach_a { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; char *label; int varno; /* loop target variable */ int slice; /* slice dimension, or 0 */ PLpgSQL_expr *expr; /* array expression */ List *body; /* List of statements */ } PLpgSQL_stmt_foreach_a; /* * OPEN a curvar */ typedef struct PLpgSQL_stmt_open { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; int curvar; int cursor_options; PLpgSQL_expr *argquery; PLpgSQL_expr *query; PLpgSQL_expr *dynquery; List *params; /* USING expressions */ } PLpgSQL_stmt_open; /* * FETCH or MOVE statement */ typedef struct PLpgSQL_stmt_fetch { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_variable *target; /* target (record or row) */ int curvar; /* cursor variable to fetch from */ FetchDirection direction; /* fetch direction */ long how_many; /* count, if constant (expr is NULL) */ PLpgSQL_expr *expr; /* count, if expression */ bool is_move; /* is this a fetch or move? */ bool returns_multiple_rows; /* can return more than one row? */ } PLpgSQL_stmt_fetch; /* * CLOSE curvar */ typedef struct PLpgSQL_stmt_close { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; int curvar; } PLpgSQL_stmt_close; /* * EXIT or CONTINUE statement */ typedef struct PLpgSQL_stmt_exit { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; bool is_exit; /* Is this an exit or a continue? */ char *label; /* NULL if it's an unlabeled EXIT/CONTINUE */ PLpgSQL_expr *cond; } PLpgSQL_stmt_exit; /* * RETURN statement */ typedef struct PLpgSQL_stmt_return { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *expr; int retvarno; } PLpgSQL_stmt_return; /* * RETURN NEXT statement */ typedef struct PLpgSQL_stmt_return_next { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *expr; int retvarno; } PLpgSQL_stmt_return_next; /* * RETURN QUERY statement */ typedef struct PLpgSQL_stmt_return_query { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *query; /* if static query */ PLpgSQL_expr *dynquery; /* if dynamic query (RETURN QUERY EXECUTE) */ List *params; /* USING arguments for dynamic query */ } PLpgSQL_stmt_return_query; /* * RAISE statement */ typedef struct PLpgSQL_stmt_raise { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; int elog_level; char *condname; /* condition name, SQLSTATE, or NULL */ char *message; /* old-style message format literal, or NULL */ List *params; /* list of expressions for old-style message */ List *options; /* list of PLpgSQL_raise_option */ } PLpgSQL_stmt_raise; /* * RAISE statement option */ typedef struct PLpgSQL_raise_option { PLpgSQL_raise_option_type opt_type; PLpgSQL_expr *expr; } PLpgSQL_raise_option; /* * ASSERT statement */ typedef struct PLpgSQL_stmt_assert { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *cond; PLpgSQL_expr *message; } PLpgSQL_stmt_assert; /* * Generic SQL statement to execute */ typedef struct PLpgSQL_stmt_execsql { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *sqlstmt; bool mod_stmt; /* is the stmt INSERT/UPDATE/DELETE/MERGE? */ bool mod_stmt_set; /* is mod_stmt valid yet? */ bool into; /* INTO supplied? */ bool strict; /* INTO STRICT flag */ PLpgSQL_variable *target; /* INTO target (record or row) */ } PLpgSQL_stmt_execsql; /* * Dynamic SQL string to execute */ typedef struct PLpgSQL_stmt_dynexecute { PLpgSQL_stmt_type cmd_type; int lineno; unsigned int stmtid; PLpgSQL_expr *query; /* string expression */ bool into; /* INTO supplied? */ bool strict; /* INTO STRICT flag */ PLpgSQL_variable *target; /* INTO target (record or row) */ List *params; /* USING expressions */ } PLpgSQL_stmt_dynexecute; /* * Hash lookup key for functions */ typedef struct PLpgSQL_func_hashkey { Oid funcOid; bool isTrigger; /* true if called as a DML trigger */ bool isEventTrigger; /* true if called as an event trigger */ /* be careful that pad bytes in this struct get zeroed! */ /* * For a trigger function, the OID of the trigger is part of the hash key * --- we want to compile the trigger function separately for each trigger * it is used with, in case the rowtype or transition table names are * different. Zero if not called as a DML trigger. */ Oid trigOid; /* * We must include the input collation as part of the hash key too, * because we have to generate different plans (with different Param * collations) for different collation settings. */ Oid inputCollation; /* * We include actual argument types in the hash key to support polymorphic * PLpgSQL functions. Be careful that extra positions are zeroed! */ Oid argtypes[FUNC_MAX_ARGS]; } PLpgSQL_func_hashkey; /* * Trigger type */ typedef enum PLpgSQL_trigtype { PLPGSQL_DML_TRIGGER, PLPGSQL_EVENT_TRIGGER, PLPGSQL_NOT_TRIGGER } PLpgSQL_trigtype; /* * Complete compiled function */ typedef struct PLpgSQL_function { char *fn_signature; Oid fn_oid; TransactionId fn_xmin; ItemPointerData fn_tid; PLpgSQL_trigtype fn_is_trigger; Oid fn_input_collation; PLpgSQL_func_hashkey *fn_hashkey; /* back-link to hashtable key */ MemoryContext fn_cxt; Oid fn_rettype; int fn_rettyplen; bool fn_retbyval; bool fn_retistuple; bool fn_retisdomain; bool fn_retset; bool fn_readonly; char fn_prokind; int fn_nargs; int fn_argvarnos[FUNC_MAX_ARGS]; int out_param_varno; int found_varno; int new_varno; int old_varno; PLpgSQL_resolve_option resolve_option; bool print_strict_params; /* extra checks */ int extra_warnings; int extra_errors; /* the datums representing the function's local variables */ int ndatums; PLpgSQL_datum **datums; Size copiable_size; /* space for locally instantiated datums */ /* function body parsetree */ PLpgSQL_stmt_block *action; /* data derived while parsing body */ unsigned int nstatements; /* counter for assigning stmtids */ bool requires_procedure_resowner; /* contains CALL or DO? */ /* these fields change when the function is used */ struct PLpgSQL_execstate *cur_estate; unsigned long use_count; } PLpgSQL_function; /* * Runtime execution data */ typedef struct PLpgSQL_execstate { PLpgSQL_function *func; /* function being executed */ TriggerData *trigdata; /* if regular trigger, data about firing */ EventTriggerData *evtrigdata; /* if event trigger, data about firing */ Datum retval; bool retisnull; Oid rettype; /* type of current retval */ Oid fn_rettype; /* info about declared function rettype */ bool retistuple; bool retisset; bool readonly_func; bool atomic; char *exitlabel; /* the "target" label of the current EXIT or * CONTINUE stmt, if any */ ErrorData *cur_error; /* current exception handler's error */ Tuplestorestate *tuple_store; /* SRFs accumulate results here */ TupleDesc tuple_store_desc; /* descriptor for tuples in tuple_store */ MemoryContext tuple_store_cxt; ResourceOwner tuple_store_owner; ReturnSetInfo *rsi; int found_varno; /* * The datums representing the function's local variables. Some of these * are local storage in this execstate, but some just point to the shared * copy belonging to the PLpgSQL_function, depending on whether or not we * need any per-execution state for the datum's dtype. */ int ndatums; PLpgSQL_datum **datums; /* context containing variable values (same as func's SPI_proc context) */ MemoryContext datum_context; /* * paramLI is what we use to pass local variable values to the executor. * It does not have a ParamExternData array; we just dynamically * instantiate parameter data as needed. By convention, PARAM_EXTERN * Params have paramid equal to the dno of the referenced local variable. */ ParamListInfo paramLI; /* EState and resowner to use for "simple" expression evaluation */ EState *simple_eval_estate; ResourceOwner simple_eval_resowner; /* if running nonatomic procedure or DO block, resowner to use for CALL */ ResourceOwner procedure_resowner; /* lookup table to use for executing type casts */ HTAB *cast_hash; /* memory context for statement-lifespan temporary values */ MemoryContext stmt_mcontext; /* current stmt context, or NULL if none */ MemoryContext stmt_mcontext_parent; /* parent of current context */ /* temporary state for results from evaluation of query or expr */ SPITupleTable *eval_tuptable; uint64 eval_processed; ExprContext *eval_econtext; /* for executing simple expressions */ /* status information for error context reporting */ PLpgSQL_stmt *err_stmt; /* current stmt */ PLpgSQL_variable *err_var; /* current variable, if in a DECLARE section */ const char *err_text; /* additional state info */ void *plugin_info; /* reserved for use by optional plugin */ } PLpgSQL_execstate; /* * A PLpgSQL_plugin structure represents an instrumentation plugin. * To instrument PL/pgSQL, a plugin library must access the rendezvous * variable "PLpgSQL_plugin" and set it to point to a PLpgSQL_plugin struct. * Typically the struct could just be static data in the plugin library. * We expect that a plugin would do this at library load time (_PG_init()). * * This structure is basically a collection of function pointers --- at * various interesting points in pl_exec.c, we call these functions * (if the pointers are non-NULL) to give the plugin a chance to watch * what we are doing. * * func_setup is called when we start a function, before we've initialized * the local variables defined by the function. * * func_beg is called when we start a function, after we've initialized * the local variables. * * func_end is called at the end of a function. * * stmt_beg and stmt_end are called before and after (respectively) each * statement. * * Also, immediately before any call to func_setup, PL/pgSQL fills in the * remaining fields with pointers to some of its own functions, allowing the * plugin to invoke those functions conveniently. The exposed functions are: * plpgsql_exec_error_callback * exec_assign_expr * exec_assign_value * exec_eval_datum * exec_cast_value * (plpgsql_exec_error_callback is not actually meant to be called by the * plugin, but rather to allow it to identify PL/pgSQL error context stack * frames. The others are useful for debugger-like plugins to examine and * set variables.) */ typedef struct PLpgSQL_plugin { /* Function pointers set up by the plugin */ void (*func_setup) (PLpgSQL_execstate *estate, PLpgSQL_function *func); void (*func_beg) (PLpgSQL_execstate *estate, PLpgSQL_function *func); void (*func_end) (PLpgSQL_execstate *estate, PLpgSQL_function *func); void (*stmt_beg) (PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt); void (*stmt_end) (PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt); /* Function pointers set by PL/pgSQL itself */ void (*error_callback) (void *arg); void (*assign_expr) (PLpgSQL_execstate *estate, PLpgSQL_datum *target, PLpgSQL_expr *expr); void (*assign_value) (PLpgSQL_execstate *estate, PLpgSQL_datum *target, Datum value, bool isNull, Oid valtype, int32 valtypmod); void (*eval_datum) (PLpgSQL_execstate *estate, PLpgSQL_datum *datum, Oid *typeId, int32 *typetypmod, Datum *value, bool *isnull); Datum (*cast_value) (PLpgSQL_execstate *estate, Datum value, bool *isnull, Oid valtype, int32 valtypmod, Oid reqtype, int32 reqtypmod); } PLpgSQL_plugin; /* * Struct types used during parsing */ typedef struct PLword { char *ident; /* palloc'd converted identifier */ bool quoted; /* Was it double-quoted? */ } PLword; typedef struct PLcword { List *idents; /* composite identifiers (list of String) */ } PLcword; typedef struct PLwdatum { PLpgSQL_datum *datum; /* referenced variable */ char *ident; /* valid if simple name */ bool quoted; List *idents; /* valid if composite name */ } PLwdatum; /********************************************************************** * Global variable declarations **********************************************************************/ typedef enum { IDENTIFIER_LOOKUP_NORMAL, /* normal processing of var names */ IDENTIFIER_LOOKUP_DECLARE, /* In DECLARE --- don't look up names */ IDENTIFIER_LOOKUP_EXPR /* In SQL expression --- special case */ } IdentifierLookup; extern IdentifierLookup plpgsql_IdentifierLookup; extern int plpgsql_variable_conflict; extern bool plpgsql_print_strict_params; extern bool plpgsql_check_asserts; /* extra compile-time and run-time checks */ #define PLPGSQL_XCHECK_NONE 0 #define PLPGSQL_XCHECK_SHADOWVAR (1 << 1) #define PLPGSQL_XCHECK_TOOMANYROWS (1 << 2) #define PLPGSQL_XCHECK_STRICTMULTIASSIGNMENT (1 << 3) #define PLPGSQL_XCHECK_ALL ((int) ~0) extern int plpgsql_extra_warnings; extern int plpgsql_extra_errors; extern bool plpgsql_check_syntax; extern bool plpgsql_DumpExecTree; extern PLpgSQL_stmt_block *plpgsql_parse_result; extern int plpgsql_nDatums; extern PLpgSQL_datum **plpgsql_Datums; extern char *plpgsql_error_funcname; extern PLpgSQL_function *plpgsql_curr_compile; extern MemoryContext plpgsql_compile_tmp_cxt; extern PLpgSQL_plugin **plpgsql_plugin_ptr; /********************************************************************** * Function declarations **********************************************************************/ /* * Functions in pl_comp.c */ extern PGDLLEXPORT PLpgSQL_function *plpgsql_compile(FunctionCallInfo fcinfo, bool forValidator); extern PLpgSQL_function *plpgsql_compile_inline(char *proc_source); extern PGDLLEXPORT void plpgsql_parser_setup(struct ParseState *pstate, PLpgSQL_expr *expr); extern bool plpgsql_parse_word(char *word1, const char *yytxt, bool lookup, PLwdatum *wdatum, PLword *word); extern bool plpgsql_parse_dblword(char *word1, char *word2, PLwdatum *wdatum, PLcword *cword); extern bool plpgsql_parse_tripword(char *word1, char *word2, char *word3, PLwdatum *wdatum, PLcword *cword); extern PLpgSQL_type *plpgsql_parse_wordtype(char *ident); extern PLpgSQL_type *plpgsql_parse_cwordtype(List *idents); extern PLpgSQL_type *plpgsql_parse_wordrowtype(char *ident); extern PLpgSQL_type *plpgsql_parse_cwordrowtype(List *idents); extern PGDLLEXPORT PLpgSQL_type *plpgsql_build_datatype(Oid typeOid, int32 typmod, Oid collation, TypeName *origtypname); extern PLpgSQL_variable *plpgsql_build_variable(const char *refname, int lineno, PLpgSQL_type *dtype, bool add2namespace); extern PLpgSQL_rec *plpgsql_build_record(const char *refname, int lineno, PLpgSQL_type *dtype, Oid rectypeid, bool add2namespace); extern PLpgSQL_recfield *plpgsql_build_recfield(PLpgSQL_rec *rec, const char *fldname); extern PGDLLEXPORT int plpgsql_recognize_err_condition(const char *condname, bool allow_sqlstate); extern PLpgSQL_condition *plpgsql_parse_err_condition(char *condname); extern void plpgsql_adddatum(PLpgSQL_datum *newdatum); extern int plpgsql_add_initdatums(int **varnos); extern void plpgsql_HashTableInit(void); /* * Functions in pl_exec.c */ extern Datum plpgsql_exec_function(PLpgSQL_function *func, FunctionCallInfo fcinfo, EState *simple_eval_estate, ResourceOwner simple_eval_resowner, ResourceOwner procedure_resowner, bool atomic); extern HeapTuple plpgsql_exec_trigger(PLpgSQL_function *func, TriggerData *trigdata); extern void plpgsql_exec_event_trigger(PLpgSQL_function *func, EventTriggerData *trigdata); extern void plpgsql_xact_cb(XactEvent event, void *arg); extern void plpgsql_subxact_cb(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg); extern PGDLLEXPORT Oid plpgsql_exec_get_datum_type(PLpgSQL_execstate *estate, PLpgSQL_datum *datum); extern void plpgsql_exec_get_datum_type_info(PLpgSQL_execstate *estate, PLpgSQL_datum *datum, Oid *typeId, int32 *typMod, Oid *collation); /* * Functions for namespace handling in pl_funcs.c */ extern void plpgsql_ns_init(void); extern void plpgsql_ns_push(const char *label, PLpgSQL_label_type label_type); extern void plpgsql_ns_pop(void); extern PLpgSQL_nsitem *plpgsql_ns_top(void); extern void plpgsql_ns_additem(PLpgSQL_nsitem_type itemtype, int itemno, const char *name); extern PGDLLEXPORT PLpgSQL_nsitem *plpgsql_ns_lookup(PLpgSQL_nsitem *ns_cur, bool localmode, const char *name1, const char *name2, const char *name3, int *names_used); extern PLpgSQL_nsitem *plpgsql_ns_lookup_label(PLpgSQL_nsitem *ns_cur, const char *name); extern PLpgSQL_nsitem *plpgsql_ns_find_nearest_loop(PLpgSQL_nsitem *ns_cur); /* * Other functions in pl_funcs.c */ extern PGDLLEXPORT const char *plpgsql_stmt_typename(PLpgSQL_stmt *stmt); extern const char *plpgsql_getdiag_kindname(PLpgSQL_getdiag_kind kind); extern void plpgsql_free_function_memory(PLpgSQL_function *func); extern void plpgsql_dumptree(PLpgSQL_function *func); /* * Scanner functions in pl_scanner.c */ extern int plpgsql_base_yylex(void); extern int plpgsql_yylex(void); extern void plpgsql_push_back_token(int token); extern bool plpgsql_token_is_unreserved_keyword(int token); extern void plpgsql_append_source_text(StringInfo buf, int startlocation, int endlocation); extern int plpgsql_peek(void); extern void plpgsql_peek2(int *tok1_p, int *tok2_p, int *tok1_loc, int *tok2_loc); extern int plpgsql_scanner_errposition(int location); extern void plpgsql_yyerror(const char *message) pg_attribute_noreturn(); extern int plpgsql_location_to_lineno(int location); extern int plpgsql_latest_lineno(void); extern void plpgsql_scanner_init(const char *str); extern void plpgsql_scanner_finish(void); /* * Externs in gram.y */ extern int plpgsql_yyparse(void); #endif /* PLPGSQL_H */