plpgsql.h File Reference

#include "access/xact.h"
#include "commands/event_trigger.h"
#include "commands/trigger.h"
#include "executor/spi.h"
#include "utils/expandedrecord.h"
#include "utils/funccache.h"
#include "utils/typcache.h"

Include dependency graph for plpgsql.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PLpgSQL_type
struct	PLpgSQL_expr
struct	PLpgSQL_datum
struct	PLpgSQL_variable
struct	PLpgSQL_var
struct	PLpgSQL_row
struct	PLpgSQL_rec
struct	PLpgSQL_recfield
struct	PLpgSQL_nsitem
struct	PLpgSQL_stmt
struct	PLpgSQL_condition
struct	PLpgSQL_exception_block
struct	PLpgSQL_exception
struct	PLpgSQL_stmt_block
struct	PLpgSQL_stmt_assign
struct	PLpgSQL_stmt_perform
struct	PLpgSQL_stmt_call
struct	PLpgSQL_stmt_commit
struct	PLpgSQL_stmt_rollback
struct	PLpgSQL_diag_item
struct	PLpgSQL_stmt_getdiag
struct	PLpgSQL_stmt_if
struct	PLpgSQL_if_elsif
struct	PLpgSQL_stmt_case
struct	PLpgSQL_case_when
struct	PLpgSQL_stmt_loop
struct	PLpgSQL_stmt_while
struct	PLpgSQL_stmt_fori
struct	PLpgSQL_stmt_forq
struct	PLpgSQL_stmt_fors
struct	PLpgSQL_stmt_forc
struct	PLpgSQL_stmt_dynfors
struct	PLpgSQL_stmt_foreach_a
struct	PLpgSQL_stmt_open
struct	PLpgSQL_stmt_fetch
struct	PLpgSQL_stmt_close
struct	PLpgSQL_stmt_exit
struct	PLpgSQL_stmt_return
struct	PLpgSQL_stmt_return_next
struct	PLpgSQL_stmt_return_query
struct	PLpgSQL_stmt_raise
struct	PLpgSQL_raise_option
struct	PLpgSQL_stmt_assert
struct	PLpgSQL_stmt_execsql
struct	PLpgSQL_stmt_dynexecute
struct	PLpgSQL_function
struct	PLpgSQL_execstate
struct	PLpgSQL_plugin
struct	PLword
struct	PLcword
struct	PLwdatum

Macros
#define	TEXTDOMAIN   PG_TEXTDOMAIN("plpgsql")
#define	_(x)   dgettext(TEXTDOMAIN, x)
#define	PLPGSQL_OTHERS   (-1)
#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)
#define	YYLTYPE   int

Typedefs
typedef enum PLpgSQL_nsitem_type	PLpgSQL_nsitem_type
typedef enum PLpgSQL_label_type	PLpgSQL_label_type
typedef enum PLpgSQL_datum_type	PLpgSQL_datum_type
typedef enum PLpgSQL_promise_type	PLpgSQL_promise_type
typedef enum PLpgSQL_type_type	PLpgSQL_type_type
typedef enum PLpgSQL_stmt_type	PLpgSQL_stmt_type
typedef enum PLpgSQL_getdiag_kind	PLpgSQL_getdiag_kind
typedef enum PLpgSQL_raise_option_type	PLpgSQL_raise_option_type
typedef enum PLpgSQL_resolve_option	PLpgSQL_resolve_option
typedef enum PLpgSQL_rwopt	PLpgSQL_rwopt
typedef struct PLpgSQL_type	PLpgSQL_type
typedef struct PLpgSQL_expr	PLpgSQL_expr
typedef struct PLpgSQL_datum	PLpgSQL_datum
typedef struct PLpgSQL_variable	PLpgSQL_variable
typedef struct PLpgSQL_var	PLpgSQL_var
typedef struct PLpgSQL_row	PLpgSQL_row
typedef struct PLpgSQL_rec	PLpgSQL_rec
typedef struct PLpgSQL_recfield	PLpgSQL_recfield
typedef struct PLpgSQL_nsitem	PLpgSQL_nsitem
typedef struct PLpgSQL_stmt	PLpgSQL_stmt
typedef struct PLpgSQL_condition	PLpgSQL_condition
typedef struct PLpgSQL_exception_block	PLpgSQL_exception_block
typedef struct PLpgSQL_exception	PLpgSQL_exception
typedef struct PLpgSQL_stmt_block	PLpgSQL_stmt_block
typedef struct PLpgSQL_stmt_assign	PLpgSQL_stmt_assign
typedef struct PLpgSQL_stmt_perform	PLpgSQL_stmt_perform
typedef struct PLpgSQL_stmt_call	PLpgSQL_stmt_call
typedef struct PLpgSQL_stmt_commit	PLpgSQL_stmt_commit
typedef struct PLpgSQL_stmt_rollback	PLpgSQL_stmt_rollback
typedef struct PLpgSQL_diag_item	PLpgSQL_diag_item
typedef struct PLpgSQL_stmt_getdiag	PLpgSQL_stmt_getdiag
typedef struct PLpgSQL_stmt_if	PLpgSQL_stmt_if
typedef struct PLpgSQL_if_elsif	PLpgSQL_if_elsif
typedef struct PLpgSQL_stmt_case	PLpgSQL_stmt_case
typedef struct PLpgSQL_case_when	PLpgSQL_case_when
typedef struct PLpgSQL_stmt_loop	PLpgSQL_stmt_loop
typedef struct PLpgSQL_stmt_while	PLpgSQL_stmt_while
typedef struct PLpgSQL_stmt_fori	PLpgSQL_stmt_fori
typedef struct PLpgSQL_stmt_forq	PLpgSQL_stmt_forq
typedef struct PLpgSQL_stmt_fors	PLpgSQL_stmt_fors
typedef struct PLpgSQL_stmt_forc	PLpgSQL_stmt_forc
typedef struct PLpgSQL_stmt_dynfors	PLpgSQL_stmt_dynfors
typedef struct PLpgSQL_stmt_foreach_a	PLpgSQL_stmt_foreach_a
typedef struct PLpgSQL_stmt_open	PLpgSQL_stmt_open
typedef struct PLpgSQL_stmt_fetch	PLpgSQL_stmt_fetch
typedef struct PLpgSQL_stmt_close	PLpgSQL_stmt_close
typedef struct PLpgSQL_stmt_exit	PLpgSQL_stmt_exit
typedef struct PLpgSQL_stmt_return	PLpgSQL_stmt_return
typedef struct PLpgSQL_stmt_return_next	PLpgSQL_stmt_return_next
typedef struct PLpgSQL_stmt_return_query	PLpgSQL_stmt_return_query
typedef struct PLpgSQL_stmt_raise	PLpgSQL_stmt_raise
typedef struct PLpgSQL_raise_option	PLpgSQL_raise_option
typedef struct PLpgSQL_stmt_assert	PLpgSQL_stmt_assert
typedef struct PLpgSQL_stmt_execsql	PLpgSQL_stmt_execsql
typedef struct PLpgSQL_stmt_dynexecute	PLpgSQL_stmt_dynexecute
typedef enum PLpgSQL_trigtype	PLpgSQL_trigtype
typedef struct PLpgSQL_function	PLpgSQL_function
typedef struct PLpgSQL_execstate	PLpgSQL_execstate
typedef struct PLpgSQL_plugin	PLpgSQL_plugin
typedef struct PLword	PLword
typedef struct PLcword	PLcword
typedef struct PLwdatum	PLwdatum
typedef void *	yyscan_t

Enumerations
enum	PLpgSQL_nsitem_type { PLPGSQL_NSTYPE_LABEL , PLPGSQL_NSTYPE_VAR , PLPGSQL_NSTYPE_REC }
enum	PLpgSQL_label_type { PLPGSQL_LABEL_BLOCK , PLPGSQL_LABEL_LOOP , PLPGSQL_LABEL_OTHER }
enum	PLpgSQL_datum_type {   PLPGSQL_DTYPE_VAR , PLPGSQL_DTYPE_ROW , PLPGSQL_DTYPE_REC , PLPGSQL_DTYPE_RECFIELD ,   PLPGSQL_DTYPE_PROMISE }
enum	PLpgSQL_promise_type {   PLPGSQL_PROMISE_NONE = 0 , 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 }
enum	PLpgSQL_type_type { PLPGSQL_TTYPE_SCALAR , PLPGSQL_TTYPE_REC , PLPGSQL_TTYPE_PSEUDO }
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 }
enum	{ PLPGSQL_RC_OK , PLPGSQL_RC_EXIT , PLPGSQL_RC_RETURN , PLPGSQL_RC_CONTINUE }
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 }
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 }
enum	PLpgSQL_resolve_option { PLPGSQL_RESOLVE_ERROR , PLPGSQL_RESOLVE_VARIABLE , PLPGSQL_RESOLVE_COLUMN }
enum	PLpgSQL_rwopt { PLPGSQL_RWOPT_UNKNOWN = 0 , PLPGSQL_RWOPT_NOPE , PLPGSQL_RWOPT_TRANSFER , PLPGSQL_RWOPT_INPLACE }
enum	PLpgSQL_trigtype { PLPGSQL_DML_TRIGGER , PLPGSQL_EVENT_TRIGGER , PLPGSQL_NOT_TRIGGER }
enum	IdentifierLookup { IDENTIFIER_LOOKUP_NORMAL , IDENTIFIER_LOOKUP_DECLARE , IDENTIFIER_LOOKUP_EXPR }

Functions
PGDLLEXPORT PLpgSQL_function *	plpgsql_compile (FunctionCallInfo fcinfo, bool forValidator)
PLpgSQL_function *	plpgsql_compile_inline (char *proc_source)
PGDLLEXPORT void	plpgsql_parser_setup (struct ParseState *pstate, PLpgSQL_expr *expr)
bool	plpgsql_parse_word (char *word1, const char *yytxt, bool lookup, PLwdatum *wdatum, PLword *word)
bool	plpgsql_parse_dblword (char *word1, char *word2, PLwdatum *wdatum, PLcword *cword)
bool	plpgsql_parse_tripword (char *word1, char *word2, char *word3, PLwdatum *wdatum, PLcword *cword)
PLpgSQL_type *	plpgsql_parse_wordtype (char *ident)
PLpgSQL_type *	plpgsql_parse_cwordtype (List *idents)
PLpgSQL_type *	plpgsql_parse_wordrowtype (char *ident)
PLpgSQL_type *	plpgsql_parse_cwordrowtype (List *idents)
PGDLLEXPORT PLpgSQL_type *	plpgsql_build_datatype (Oid typeOid, int32 typmod, Oid collation, TypeName *origtypname)
PLpgSQL_type *	plpgsql_build_datatype_arrayof (PLpgSQL_type *dtype)
PLpgSQL_variable *	plpgsql_build_variable (const char *refname, int lineno, PLpgSQL_type *dtype, bool add2namespace)
PLpgSQL_rec *	plpgsql_build_record (const char *refname, int lineno, PLpgSQL_type *dtype, Oid rectypeid, bool add2namespace)
PLpgSQL_recfield *	plpgsql_build_recfield (PLpgSQL_rec *rec, const char *fldname)
PGDLLEXPORT int	plpgsql_recognize_err_condition (const char *condname, bool allow_sqlstate)
PLpgSQL_condition *	plpgsql_parse_err_condition (char *condname)
void	plpgsql_adddatum (PLpgSQL_datum *newdatum)
int	plpgsql_add_initdatums (int **varnos)
Datum	plpgsql_exec_function (PLpgSQL_function *func, FunctionCallInfo fcinfo, EState *simple_eval_estate, ResourceOwner simple_eval_resowner, ResourceOwner procedure_resowner, bool atomic)
HeapTuple	plpgsql_exec_trigger (PLpgSQL_function *func, TriggerData *trigdata)
void	plpgsql_exec_event_trigger (PLpgSQL_function *func, EventTriggerData *trigdata)
void	plpgsql_xact_cb (XactEvent event, void *arg)
void	plpgsql_subxact_cb (SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg)
PGDLLEXPORT Oid	plpgsql_exec_get_datum_type (PLpgSQL_execstate *estate, PLpgSQL_datum *datum)
void	plpgsql_exec_get_datum_type_info (PLpgSQL_execstate *estate, PLpgSQL_datum *datum, Oid *typeId, int32 *typMod, Oid *collation)
void	plpgsql_ns_init (void)
void	plpgsql_ns_push (const char *label, PLpgSQL_label_type label_type)
void	plpgsql_ns_pop (void)
PLpgSQL_nsitem *	plpgsql_ns_top (void)
void	plpgsql_ns_additem (PLpgSQL_nsitem_type itemtype, int itemno, const char *name)
PGDLLEXPORT PLpgSQL_nsitem *	plpgsql_ns_lookup (PLpgSQL_nsitem *ns_cur, bool localmode, const char *name1, const char *name2, const char *name3, int *names_used)
PLpgSQL_nsitem *	plpgsql_ns_lookup_label (PLpgSQL_nsitem *ns_cur, const char *name)
PLpgSQL_nsitem *	plpgsql_ns_find_nearest_loop (PLpgSQL_nsitem *ns_cur)
PGDLLEXPORT const char *	plpgsql_stmt_typename (PLpgSQL_stmt *stmt)
const char *	plpgsql_getdiag_kindname (PLpgSQL_getdiag_kind kind)
void	plpgsql_mark_local_assignment_targets (PLpgSQL_function *func)
void	plpgsql_free_function_memory (PLpgSQL_function *func)
void	plpgsql_delete_callback (CachedFunction *cfunc)
void	plpgsql_dumptree (PLpgSQL_function *func)
int	plpgsql_yylex (union YYSTYPE *yylvalp, YYLTYPE *yyllocp, yyscan_t yyscanner)
int	plpgsql_token_length (yyscan_t yyscanner)
void	plpgsql_push_back_token (int token, union YYSTYPE *yylvalp, YYLTYPE *yyllocp, yyscan_t yyscanner)
bool	plpgsql_token_is_unreserved_keyword (int token)
void	plpgsql_append_source_text (StringInfo buf, int startlocation, int endlocation, yyscan_t yyscanner)
int	plpgsql_peek (yyscan_t yyscanner)
void	plpgsql_peek2 (int *tok1_p, int *tok2_p, int *tok1_loc, int *tok2_loc, yyscan_t yyscanner)
int	plpgsql_scanner_errposition (int location, yyscan_t yyscanner)
pg_noreturn void	plpgsql_yyerror (YYLTYPE *yyllocp, PLpgSQL_stmt_block **plpgsql_parse_result_p, yyscan_t yyscanner, const char *message)
int	plpgsql_location_to_lineno (int location, yyscan_t yyscanner)
int	plpgsql_latest_lineno (yyscan_t yyscanner)
yyscan_t	plpgsql_scanner_init (const char *str)
void	plpgsql_scanner_finish (yyscan_t yyscanner)
int	plpgsql_yyparse (PLpgSQL_stmt_block **plpgsql_parse_result_p, yyscan_t yyscanner)

Variables
IdentifierLookup	plpgsql_IdentifierLookup
int	plpgsql_variable_conflict
bool	plpgsql_print_strict_params
bool	plpgsql_check_asserts
int	plpgsql_extra_warnings
int	plpgsql_extra_errors
bool	plpgsql_check_syntax
bool	plpgsql_DumpExecTree
int	plpgsql_nDatums
PLpgSQL_datum **	plpgsql_Datums
char *	plpgsql_error_funcname
PLpgSQL_function *	plpgsql_curr_compile
MemoryContext	plpgsql_compile_tmp_cxt
PLpgSQL_plugin **	plpgsql_plugin_ptr

Macro Definition Documentation

_

#define _

(

x

)

dgettext(TEXTDOMAIN, x)

Definition at line 37 of file plpgsql.h.

PLPGSQL_OTHERS

#define PLPGSQL_OTHERS   (-1)

Definition at line 500 of file plpgsql.h.

PLPGSQL_XCHECK_ALL

#define PLPGSQL_XCHECK_ALL   ((int) ~0)

Definition at line 1198 of file plpgsql.h.

PLPGSQL_XCHECK_NONE

#define PLPGSQL_XCHECK_NONE   0

Definition at line 1194 of file plpgsql.h.

PLPGSQL_XCHECK_SHADOWVAR

#define PLPGSQL_XCHECK_SHADOWVAR   (1 << 1)

Definition at line 1195 of file plpgsql.h.

PLPGSQL_XCHECK_STRICTMULTIASSIGNMENT

#define PLPGSQL_XCHECK_STRICTMULTIASSIGNMENT   (1 << 3)

Definition at line 1197 of file plpgsql.h.

PLPGSQL_XCHECK_TOOMANYROWS

#define PLPGSQL_XCHECK_TOOMANYROWS   (1 << 2)

Definition at line 1196 of file plpgsql.h.

TEXTDOMAIN

#define TEXTDOMAIN   PG_TEXTDOMAIN("plpgsql")

Definition at line 34 of file plpgsql.h.

YYLTYPE

#define YYLTYPE   int

Definition at line 1309 of file plpgsql.h.

Typedef Documentation

PLcword

typedef struct PLcword PLcword

PLpgSQL_case_when

typedef struct PLpgSQL_case_when PLpgSQL_case_when

PLpgSQL_condition

typedef struct PLpgSQL_condition PLpgSQL_condition

PLpgSQL_datum

typedef struct PLpgSQL_datum PLpgSQL_datum

PLpgSQL_datum_type

typedef enum PLpgSQL_datum_type PLpgSQL_datum_type

PLpgSQL_diag_item

typedef struct PLpgSQL_diag_item PLpgSQL_diag_item

PLpgSQL_exception

typedef struct PLpgSQL_exception PLpgSQL_exception

PLpgSQL_exception_block

typedef struct PLpgSQL_exception_block PLpgSQL_exception_block

PLpgSQL_execstate

typedef struct PLpgSQL_execstate PLpgSQL_execstate

PLpgSQL_expr

typedef struct PLpgSQL_expr PLpgSQL_expr

PLpgSQL_function

typedef struct PLpgSQL_function PLpgSQL_function

PLpgSQL_getdiag_kind

typedef enum PLpgSQL_getdiag_kind PLpgSQL_getdiag_kind

PLpgSQL_if_elsif

typedef struct PLpgSQL_if_elsif PLpgSQL_if_elsif

PLpgSQL_label_type

typedef enum PLpgSQL_label_type PLpgSQL_label_type

PLpgSQL_nsitem

typedef struct PLpgSQL_nsitem PLpgSQL_nsitem

PLpgSQL_nsitem_type

typedef enum PLpgSQL_nsitem_type PLpgSQL_nsitem_type

PLpgSQL_plugin

typedef struct PLpgSQL_plugin PLpgSQL_plugin

PLpgSQL_promise_type

typedef enum PLpgSQL_promise_type PLpgSQL_promise_type

PLpgSQL_raise_option

typedef struct PLpgSQL_raise_option PLpgSQL_raise_option

PLpgSQL_raise_option_type

typedef enum PLpgSQL_raise_option_type PLpgSQL_raise_option_type

PLpgSQL_rec

typedef struct PLpgSQL_rec PLpgSQL_rec

PLpgSQL_recfield

typedef struct PLpgSQL_recfield PLpgSQL_recfield

PLpgSQL_resolve_option

typedef enum PLpgSQL_resolve_option PLpgSQL_resolve_option

PLpgSQL_row

typedef struct PLpgSQL_row PLpgSQL_row

PLpgSQL_rwopt

typedef enum PLpgSQL_rwopt PLpgSQL_rwopt

PLpgSQL_stmt

typedef struct PLpgSQL_stmt PLpgSQL_stmt

PLpgSQL_stmt_assert

typedef struct PLpgSQL_stmt_assert PLpgSQL_stmt_assert

PLpgSQL_stmt_assign

typedef struct PLpgSQL_stmt_assign PLpgSQL_stmt_assign

PLpgSQL_stmt_block

typedef struct PLpgSQL_stmt_block PLpgSQL_stmt_block

PLpgSQL_stmt_call

typedef struct PLpgSQL_stmt_call PLpgSQL_stmt_call

PLpgSQL_stmt_case

typedef struct PLpgSQL_stmt_case PLpgSQL_stmt_case

PLpgSQL_stmt_close

typedef struct PLpgSQL_stmt_close PLpgSQL_stmt_close

PLpgSQL_stmt_commit

typedef struct PLpgSQL_stmt_commit PLpgSQL_stmt_commit

PLpgSQL_stmt_dynexecute

typedef struct PLpgSQL_stmt_dynexecute PLpgSQL_stmt_dynexecute

PLpgSQL_stmt_dynfors

typedef struct PLpgSQL_stmt_dynfors PLpgSQL_stmt_dynfors

PLpgSQL_stmt_execsql

typedef struct PLpgSQL_stmt_execsql PLpgSQL_stmt_execsql

PLpgSQL_stmt_exit

typedef struct PLpgSQL_stmt_exit PLpgSQL_stmt_exit

PLpgSQL_stmt_fetch

typedef struct PLpgSQL_stmt_fetch PLpgSQL_stmt_fetch

PLpgSQL_stmt_forc

typedef struct PLpgSQL_stmt_forc PLpgSQL_stmt_forc

PLpgSQL_stmt_foreach_a

typedef struct PLpgSQL_stmt_foreach_a PLpgSQL_stmt_foreach_a

PLpgSQL_stmt_fori

typedef struct PLpgSQL_stmt_fori PLpgSQL_stmt_fori

PLpgSQL_stmt_forq

typedef struct PLpgSQL_stmt_forq PLpgSQL_stmt_forq

PLpgSQL_stmt_fors

typedef struct PLpgSQL_stmt_fors PLpgSQL_stmt_fors

PLpgSQL_stmt_getdiag

typedef struct PLpgSQL_stmt_getdiag PLpgSQL_stmt_getdiag

PLpgSQL_stmt_if

typedef struct PLpgSQL_stmt_if PLpgSQL_stmt_if

PLpgSQL_stmt_loop

typedef struct PLpgSQL_stmt_loop PLpgSQL_stmt_loop

PLpgSQL_stmt_open

typedef struct PLpgSQL_stmt_open PLpgSQL_stmt_open

PLpgSQL_stmt_perform

typedef struct PLpgSQL_stmt_perform PLpgSQL_stmt_perform

PLpgSQL_stmt_raise

typedef struct PLpgSQL_stmt_raise PLpgSQL_stmt_raise

PLpgSQL_stmt_return

typedef struct PLpgSQL_stmt_return PLpgSQL_stmt_return

PLpgSQL_stmt_return_next

typedef struct PLpgSQL_stmt_return_next PLpgSQL_stmt_return_next

PLpgSQL_stmt_return_query

typedef struct PLpgSQL_stmt_return_query PLpgSQL_stmt_return_query

PLpgSQL_stmt_rollback

typedef struct PLpgSQL_stmt_rollback PLpgSQL_stmt_rollback

PLpgSQL_stmt_type

typedef enum PLpgSQL_stmt_type PLpgSQL_stmt_type

PLpgSQL_stmt_while

typedef struct PLpgSQL_stmt_while PLpgSQL_stmt_while

PLpgSQL_trigtype

typedef enum PLpgSQL_trigtype PLpgSQL_trigtype

PLpgSQL_type

typedef struct PLpgSQL_type PLpgSQL_type

PLpgSQL_type_type

typedef enum PLpgSQL_type_type PLpgSQL_type_type

PLpgSQL_var

typedef struct PLpgSQL_var PLpgSQL_var

PLpgSQL_variable

typedef struct PLpgSQL_variable PLpgSQL_variable

PLwdatum

typedef struct PLwdatum PLwdatum

PLword

typedef struct PLword PLword

yyscan_t

typedef void* yyscan_t

Definition at line 1310 of file plpgsql.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
PLPGSQL_RC_OK
PLPGSQL_RC_EXIT
PLPGSQL_RC_RETURN
PLPGSQL_RC_CONTINUE

Definition at line 137 of file plpgsql.h.

{
    PLPGSQL_RC_OK,
    PLPGSQL_RC_EXIT,
    PLPGSQL_RC_RETURN,
    PLPGSQL_RC_CONTINUE,
};

IdentifierLookup

enum IdentifierLookup

Enumerator
IDENTIFIER_LOOKUP_NORMAL
IDENTIFIER_LOOKUP_DECLARE
IDENTIFIER_LOOKUP_EXPR

Definition at line 1178 of file plpgsql.h.

{
    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;

PLpgSQL_datum_type

enum PLpgSQL_datum_type

Enumerator
PLPGSQL_DTYPE_VAR
PLPGSQL_DTYPE_ROW
PLPGSQL_DTYPE_REC
PLPGSQL_DTYPE_RECFIELD
PLPGSQL_DTYPE_PROMISE

Definition at line 62 of file plpgsql.h.

{
    PLPGSQL_DTYPE_VAR,
    PLPGSQL_DTYPE_ROW,
    PLPGSQL_DTYPE_REC,
    PLPGSQL_DTYPE_RECFIELD,
    PLPGSQL_DTYPE_PROMISE,
} PLpgSQL_datum_type;

PLpgSQL_getdiag_kind

enum PLpgSQL_getdiag_kind

Enumerator
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

Definition at line 148 of file plpgsql.h.

{
    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;

PLpgSQL_label_type

enum PLpgSQL_label_type

Enumerator
PLPGSQL_LABEL_BLOCK
PLPGSQL_LABEL_LOOP
PLPGSQL_LABEL_OTHER

Definition at line 52 of file plpgsql.h.

{
    PLPGSQL_LABEL_BLOCK,        /* DECLARE/BEGIN block */
    PLPGSQL_LABEL_LOOP,         /* looping construct */
    PLPGSQL_LABEL_OTHER,        /* anything else */
} PLpgSQL_label_type;

PLpgSQL_nsitem_type

enum PLpgSQL_nsitem_type

Enumerator
PLPGSQL_NSTYPE_LABEL
PLPGSQL_NSTYPE_VAR
PLPGSQL_NSTYPE_REC

Definition at line 42 of file plpgsql.h.

{
    PLPGSQL_NSTYPE_LABEL,       /* block label */
    PLPGSQL_NSTYPE_VAR,         /* scalar variable */
    PLPGSQL_NSTYPE_REC,         /* composite variable */
} PLpgSQL_nsitem_type;

PLpgSQL_promise_type

enum PLpgSQL_promise_type

Enumerator
PLPGSQL_PROMISE_NONE
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

Definition at line 74 of file plpgsql.h.

{
    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;

PLpgSQL_raise_option_type

enum PLpgSQL_raise_option_type

Enumerator
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

Definition at line 168 of file plpgsql.h.

{
    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;

PLpgSQL_resolve_option

enum PLpgSQL_resolve_option

Enumerator
PLPGSQL_RESOLVE_ERROR
PLPGSQL_RESOLVE_VARIABLE
PLPGSQL_RESOLVE_COLUMN

Definition at line 184 of file plpgsql.h.

{
    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;

PLpgSQL_rwopt

enum PLpgSQL_rwopt

Enumerator
PLPGSQL_RWOPT_UNKNOWN
PLPGSQL_RWOPT_NOPE
PLPGSQL_RWOPT_TRANSFER
PLPGSQL_RWOPT_INPLACE

Definition at line 194 of file plpgsql.h.

{
    PLPGSQL_RWOPT_UNKNOWN = 0,  /* applicability not determined yet */
    PLPGSQL_RWOPT_NOPE,         /* cannot do any optimization */
    PLPGSQL_RWOPT_TRANSFER,     /* transfer the old value into expr state */
    PLPGSQL_RWOPT_INPLACE,      /* pass value as R/W to top-level function */
} PLpgSQL_rwopt;

PLpgSQL_stmt_type

enum PLpgSQL_stmt_type

Enumerator
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

Definition at line 103 of file plpgsql.h.

{
    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;

PLpgSQL_trigtype

enum PLpgSQL_trigtype

Enumerator
PLPGSQL_DML_TRIGGER
PLPGSQL_EVENT_TRIGGER
PLPGSQL_NOT_TRIGGER

Definition at line 948 of file plpgsql.h.

{
    PLPGSQL_DML_TRIGGER,
    PLPGSQL_EVENT_TRIGGER,
    PLPGSQL_NOT_TRIGGER,
} PLpgSQL_trigtype;

PLpgSQL_type_type

enum PLpgSQL_type_type

Enumerator
PLPGSQL_TTYPE_SCALAR
PLPGSQL_TTYPE_REC
PLPGSQL_TTYPE_PSEUDO

Definition at line 93 of file plpgsql.h.

{
    PLPGSQL_TTYPE_SCALAR,       /* scalar types and domains */
    PLPGSQL_TTYPE_REC,          /* composite types, including RECORD */
    PLPGSQL_TTYPE_PSEUDO,       /* pseudotypes */
} PLpgSQL_type_type;

Function Documentation

plpgsql_add_initdatums()

int plpgsql_add_initdatums

(

int **

varnos

)

Definition at line 2299 of file pl_comp.c.

{
    int         i;
    int         n = 0;
 
    /*
     * The set of dtypes recognized here must match what exec_stmt_block()
     * cares about (re)initializing at block entry.
     */
    for (i = datums_last; i < plpgsql_nDatums; i++)
    {
        switch (plpgsql_Datums[i]->dtype)
        {
            case PLPGSQL_DTYPE_VAR:
            case PLPGSQL_DTYPE_REC:
                n++;
                break;
 
            default:
                break;
        }
    }
 
    if (varnos != NULL)
    {
        if (n > 0)
        {
            *varnos = (int *) palloc(sizeof(int) * n);
 
            n = 0;
            for (i = datums_last; i < plpgsql_nDatums; i++)
            {
                switch (plpgsql_Datums[i]->dtype)
                {
                    case PLPGSQL_DTYPE_VAR:
                    case PLPGSQL_DTYPE_REC:
                        (*varnos)[n++] = plpgsql_Datums[i]->dno;
 
                    default:
                        break;
                }
            }
        }
        else
            *varnos = NULL;
    }
 
    datums_last = plpgsql_nDatums;
    return n;
}

References datums_last, PLpgSQL_datum::dno, i, palloc(), plpgsql_Datums, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_VAR, and plpgsql_nDatums.

plpgsql_adddatum()

void plpgsql_adddatum

(

PLpgSQL_datum *

newdatum

)

Definition at line 2238 of file pl_comp.c.

{
    if (plpgsql_nDatums == datums_alloc)
    {
        datums_alloc *= 2;
        plpgsql_Datums = repalloc(plpgsql_Datums, sizeof(PLpgSQL_datum *) * datums_alloc);
    }
 
    newdatum->dno = plpgsql_nDatums;
    plpgsql_Datums[plpgsql_nDatums++] = newdatum;
}

References datums_alloc, PLpgSQL_datum::dno, plpgsql_Datums, plpgsql_nDatums, and repalloc().

Referenced by plpgsql_build_recfield(), plpgsql_build_record(), plpgsql_build_variable(), and plpgsql_compile_callback().

plpgsql_append_source_text()

void plpgsql_append_source_text	(	StringInfo	buf,
		int	startlocation,
		int	endlocation,
		yyscan_t	yyscanner
	)

Definition at line 435 of file pl_scanner.c.

{
    Assert(startlocation <= endlocation);
    appendBinaryStringInfo(buf, yyextra->scanorig + startlocation,
                           endlocation - startlocation);
}

References appendBinaryStringInfo(), Assert(), buf, and yyextra.

plpgsql_build_datatype()

PGDLLEXPORT PLpgSQL_type * plpgsql_build_datatype	(	Oid	typeOid,
		int32	typmod,
		Oid	collation,
		TypeName *	origtypname
	)

Definition at line 1973 of file pl_comp.c.

{
    HeapTuple   typeTup;
    PLpgSQL_type *typ;
 
    typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeOid));
    if (!HeapTupleIsValid(typeTup))
        elog(ERROR, "cache lookup failed for type %u", typeOid);
 
    typ = build_datatype(typeTup, typmod, collation, origtypname);
 
    ReleaseSysCache(typeTup);
 
    return typ;
}

References build_datatype(), elog, ERROR, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), and SearchSysCache1().

Referenced by exec_stmt_case(), plpgsql_build_datatype_arrayof(), plpgsql_compile_callback(), plpgsql_compile_inline(), plpgsql_parse_cwordrowtype(), and plpgsql_parse_wordrowtype().

plpgsql_build_datatype_arrayof()

PLpgSQL_type * plpgsql_build_datatype_arrayof

(

PLpgSQL_type *

dtype

)

Definition at line 2107 of file pl_comp.c.

{
    Oid         array_typeid;
 
    /*
     * If it's already an array type, use it as-is: Postgres doesn't do nested
     * arrays.
     */
    if (dtype->typisarray)
        return dtype;
 
    array_typeid = get_array_type(dtype->typoid);
    if (!OidIsValid(array_typeid))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("could not find array type for data type %s",
                        format_type_be(dtype->typoid))));
 
    /* Note we inherit typmod and collation, if any, from the element type */
    return plpgsql_build_datatype(array_typeid, dtype->atttypmod,
                                  dtype->collation, NULL);
}

References PLpgSQL_type::atttypmod, PLpgSQL_type::collation, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_array_type(), OidIsValid, plpgsql_build_datatype(), PLpgSQL_type::typisarray, and PLpgSQL_type::typoid.

plpgsql_build_recfield()

PLpgSQL_recfield * plpgsql_build_recfield	(	PLpgSQL_rec *	rec,
		const char *	fldname
	)

Definition at line 1924 of file pl_comp.c.

{
    PLpgSQL_recfield *recfield;
    int         i;
 
    /* search for an existing datum referencing this field */
    i = rec->firstfield;
    while (i >= 0)
    {
        PLpgSQL_recfield *fld = (PLpgSQL_recfield *) plpgsql_Datums[i];
 
        Assert(fld->dtype == PLPGSQL_DTYPE_RECFIELD &&
               fld->recparentno == rec->dno);
        if (strcmp(fld->fieldname, fldname) == 0)
            return fld;
        i = fld->nextfield;
    }
 
    /* nope, so make a new one */
    recfield = palloc0(sizeof(PLpgSQL_recfield));
    recfield->dtype = PLPGSQL_DTYPE_RECFIELD;
    recfield->fieldname = pstrdup(fldname);
    recfield->recparentno = rec->dno;
    recfield->rectupledescid = INVALID_TUPLEDESC_IDENTIFIER;
 
    plpgsql_adddatum((PLpgSQL_datum *) recfield);
 
    /* now we can link it into the parent's chain */
    recfield->nextfield = rec->firstfield;
    rec->firstfield = recfield->dno;
 
    return recfield;
}

References Assert(), PLpgSQL_rec::dno, PLpgSQL_recfield::dno, PLpgSQL_recfield::dtype, PLpgSQL_recfield::fieldname, PLpgSQL_rec::firstfield, i, INVALID_TUPLEDESC_IDENTIFIER, PLpgSQL_recfield::nextfield, palloc0(), plpgsql_adddatum(), plpgsql_Datums, PLPGSQL_DTYPE_RECFIELD, pstrdup(), PLpgSQL_recfield::recparentno, and PLpgSQL_recfield::rectupledescid.

Referenced by plpgsql_parse_dblword(), and plpgsql_parse_tripword().

plpgsql_build_record()

PLpgSQL_rec * plpgsql_build_record	(	const char *	refname,
		int	lineno,
		PLpgSQL_type *	dtype,
		Oid	rectypeid,
		bool	add2namespace
	)

Definition at line 1830 of file pl_comp.c.

{
    PLpgSQL_rec *rec;
 
    rec = palloc0(sizeof(PLpgSQL_rec));
    rec->dtype = PLPGSQL_DTYPE_REC;
    rec->refname = pstrdup(refname);
    rec->lineno = lineno;
    /* other fields are left as 0, might be changed by caller */
    rec->datatype = dtype;
    rec->rectypeid = rectypeid;
    rec->firstfield = -1;
    rec->erh = NULL;
    plpgsql_adddatum((PLpgSQL_datum *) rec);
    if (add2namespace)
        plpgsql_ns_additem(PLPGSQL_NSTYPE_REC, rec->dno, rec->refname);
 
    return rec;
}

References PLpgSQL_rec::datatype, PLpgSQL_rec::dno, PLpgSQL_rec::dtype, PLpgSQL_rec::erh, PLpgSQL_rec::firstfield, PLpgSQL_rec::lineno, palloc0(), plpgsql_adddatum(), PLPGSQL_DTYPE_REC, plpgsql_ns_additem(), PLPGSQL_NSTYPE_REC, pstrdup(), PLpgSQL_rec::rectypeid, and PLpgSQL_rec::refname.

Referenced by plpgsql_build_variable(), and plpgsql_compile_callback().

plpgsql_build_variable()

PLpgSQL_variable * plpgsql_build_variable	(	const char *	refname,
		int	lineno,
		PLpgSQL_type *	dtype,
		bool	add2namespace
	)

Definition at line 1767 of file pl_comp.c.

{
    PLpgSQL_variable *result;
 
    switch (dtype->ttype)
    {
        case PLPGSQL_TTYPE_SCALAR:
            {
                /* Ordinary scalar datatype */
                PLpgSQL_var *var;
 
                var = palloc0(sizeof(PLpgSQL_var));
                var->dtype = PLPGSQL_DTYPE_VAR;
                var->refname = pstrdup(refname);
                var->lineno = lineno;
                var->datatype = dtype;
                /* other fields are left as 0, might be changed by caller */
 
                /* preset to NULL */
                var->value = 0;
                var->isnull = true;
                var->freeval = false;
 
                plpgsql_adddatum((PLpgSQL_datum *) var);
                if (add2namespace)
                    plpgsql_ns_additem(PLPGSQL_NSTYPE_VAR,
                                       var->dno,
                                       refname);
                result = (PLpgSQL_variable *) var;
                break;
            }
        case PLPGSQL_TTYPE_REC:
            {
                /* Composite type -- build a record variable */
                PLpgSQL_rec *rec;
 
                rec = plpgsql_build_record(refname, lineno,
                                           dtype, dtype->typoid,
                                           add2namespace);
                result = (PLpgSQL_variable *) rec;
                break;
            }
        case PLPGSQL_TTYPE_PSEUDO:
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("variable \"%s\" has pseudo-type %s",
                            refname, format_type_be(dtype->typoid))));
            result = NULL;      /* keep compiler quiet */
            break;
        default:
            elog(ERROR, "unrecognized ttype: %d", dtype->ttype);
            result = NULL;      /* keep compiler quiet */
            break;
    }
 
    return result;
}

References PLpgSQL_var::datatype, PLpgSQL_var::dno, PLpgSQL_var::dtype, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), PLpgSQL_var::freeval, PLpgSQL_var::isnull, PLpgSQL_var::lineno, palloc0(), plpgsql_adddatum(), plpgsql_build_record(), PLPGSQL_DTYPE_VAR, plpgsql_ns_additem(), PLPGSQL_NSTYPE_VAR, PLPGSQL_TTYPE_PSEUDO, PLPGSQL_TTYPE_REC, PLPGSQL_TTYPE_SCALAR, pstrdup(), PLpgSQL_var::refname, PLpgSQL_type::ttype, PLpgSQL_type::typoid, and PLpgSQL_var::value.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_compile()

PGDLLEXPORT PLpgSQL_function * plpgsql_compile	(	FunctionCallInfo	fcinfo,
		bool	forValidator
	)

Definition at line 106 of file pl_comp.c.

{
    PLpgSQL_function *function;
 
    /*
     * funccache.c manages re-use of existing PLpgSQL_function caches.
     *
     * In PL/pgSQL we use fn_extra directly as the pointer to the long-lived
     * function cache entry; we have no need for any query-lifespan cache.
     * Also, we don't need to make the cache key depend on composite result
     * type (at least for now).
     */
    function = (PLpgSQL_function *)
        cached_function_compile(fcinfo,
                                fcinfo->flinfo->fn_extra,
                                plpgsql_compile_callback,
                                plpgsql_delete_callback,
                                sizeof(PLpgSQL_function),
                                false,
                                forValidator);
 
    /*
     * Save pointer in FmgrInfo to avoid search on subsequent calls
     */
    fcinfo->flinfo->fn_extra = function;
 
    /*
     * Finally return the compiled function
     */
    return function;
}

References cached_function_compile(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, function, plpgsql_compile_callback(), and plpgsql_delete_callback().

Referenced by plpgsql_call_handler(), and plpgsql_validator().

plpgsql_compile_inline()

PLpgSQL_function * plpgsql_compile_inline

(

char *

proc_source

)

Definition at line 743 of file pl_comp.c.

{
    yyscan_t    scanner;
    char       *func_name = "inline_code_block";
    PLpgSQL_function *function;
    struct compile_error_callback_arg cbarg;
    ErrorContextCallback plerrcontext;
    PLpgSQL_variable *var;
    int         parse_rc;
    MemoryContext func_cxt;
 
    /*
     * Setup the scanner input and error info.
     */
    scanner = plpgsql_scanner_init(proc_source);
 
    plpgsql_error_funcname = func_name;
 
    /*
     * Setup error traceback support for ereport()
     */
    cbarg.proc_source = proc_source;
    cbarg.yyscanner = scanner;
    plerrcontext.callback = plpgsql_compile_error_callback;
    plerrcontext.arg = &cbarg;
    plerrcontext.previous = error_context_stack;
    error_context_stack = &plerrcontext;
 
    /* Do extra syntax checking if check_function_bodies is on */
    plpgsql_check_syntax = check_function_bodies;
 
    /* Function struct does not live past current statement */
    function = (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function));
 
    plpgsql_curr_compile = function;
 
    /*
     * All the rest of the compile-time storage (e.g. parse tree) is kept in
     * its own memory context, so it can be reclaimed easily.
     */
    func_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                     "PL/pgSQL inline code context",
                                     ALLOCSET_DEFAULT_SIZES);
    plpgsql_compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);
 
    function->fn_signature = pstrdup(func_name);
    function->fn_is_trigger = PLPGSQL_NOT_TRIGGER;
    function->fn_input_collation = InvalidOid;
    function->fn_cxt = func_cxt;
    function->out_param_varno = -1; /* set up for no OUT param */
    function->resolve_option = plpgsql_variable_conflict;
    function->print_strict_params = plpgsql_print_strict_params;
 
    /*
     * don't do extra validation for inline code as we don't want to add spam
     * at runtime
     */
    function->extra_warnings = 0;
    function->extra_errors = 0;
 
    function->nstatements = 0;
    function->requires_procedure_resowner = false;
    function->has_exception_block = false;
 
    plpgsql_ns_init();
    plpgsql_ns_push(func_name, PLPGSQL_LABEL_BLOCK);
    plpgsql_DumpExecTree = false;
    plpgsql_start_datums();
 
    /* Set up as though in a function returning VOID */
    function->fn_rettype = VOIDOID;
    function->fn_retset = false;
    function->fn_retistuple = false;
    function->fn_retisdomain = false;
    function->fn_prokind = PROKIND_FUNCTION;
    /* a bit of hardwired knowledge about type VOID here */
    function->fn_retbyval = true;
    function->fn_rettyplen = sizeof(int32);
 
    /*
     * Remember if function is STABLE/IMMUTABLE.  XXX would it be better to
     * set this true inside a read-only transaction?  Not clear.
     */
    function->fn_readonly = false;
 
    /*
     * Create the magic FOUND variable.
     */
    var = plpgsql_build_variable("found", 0,
                                 plpgsql_build_datatype(BOOLOID,
                                                        -1,
                                                        InvalidOid,
                                                        NULL),
                                 true);
    function->found_varno = var->dno;
 
    /*
     * Now parse the function's text
     */
    parse_rc = plpgsql_yyparse(&function->action, scanner);
    if (parse_rc != 0)
        elog(ERROR, "plpgsql parser returned %d", parse_rc);
 
    plpgsql_scanner_finish(scanner);
 
    /*
     * If it returns VOID (always true at the moment), we allow control to
     * fall off the end without an explicit RETURN statement.
     */
    if (function->fn_rettype == VOIDOID)
        add_dummy_return(function);
 
    /*
     * Complete the function's info
     */
    function->fn_nargs = 0;
 
    plpgsql_finish_datums(function);
 
    if (function->has_exception_block)
        plpgsql_mark_local_assignment_targets(function);
 
    /* Debug dump for completed functions */
    if (plpgsql_DumpExecTree)
        plpgsql_dumptree(function);
 
    /*
     * Pop the error context stack
     */
    error_context_stack = plerrcontext.previous;
    plpgsql_error_funcname = NULL;
 
    plpgsql_check_syntax = false;
 
    MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
    plpgsql_compile_tmp_cxt = NULL;
    return function;
}

References add_dummy_return(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, check_function_bodies, CurrentMemoryContext, PLpgSQL_variable::dno, elog, ERROR, error_context_stack, function, InvalidOid, MemoryContextSwitchTo(), palloc0(), plpgsql_build_datatype(), plpgsql_build_variable(), plpgsql_check_syntax, plpgsql_compile_error_callback(), plpgsql_compile_tmp_cxt, plpgsql_curr_compile, plpgsql_DumpExecTree, plpgsql_dumptree(), plpgsql_error_funcname, plpgsql_finish_datums(), PLPGSQL_LABEL_BLOCK, plpgsql_mark_local_assignment_targets(), PLPGSQL_NOT_TRIGGER, plpgsql_ns_init(), plpgsql_ns_push(), plpgsql_print_strict_params, plpgsql_scanner_finish(), plpgsql_scanner_init(), plpgsql_start_datums(), plpgsql_variable_conflict, plpgsql_yyparse(), ErrorContextCallback::previous, compile_error_callback_arg::proc_source, pstrdup(), and compile_error_callback_arg::yyscanner.

Referenced by plpgsql_inline_handler().

plpgsql_delete_callback()

void plpgsql_delete_callback

(

CachedFunction *

cfunc

)

Definition at line 772 of file pl_funcs.c.

{
    plpgsql_free_function_memory((PLpgSQL_function *) cfunc);
}

References plpgsql_free_function_memory().

Referenced by plpgsql_compile().

plpgsql_dumptree()

void plpgsql_dumptree

(

PLpgSQL_function *

func

)

Definition at line 1601 of file pl_funcs.c.

{
    int         i;
    PLpgSQL_datum *d;
 
    printf("\nExecution tree of successfully compiled PL/pgSQL function %s:\n",
           func->fn_signature);
 
    printf("\nFunction's data area:\n");
    for (i = 0; i < func->ndatums; i++)
    {
        d = func->datums[i];
 
        printf("    entry %d: ", i);
        switch (d->dtype)
        {
            case PLPGSQL_DTYPE_VAR:
            case PLPGSQL_DTYPE_PROMISE:
                {
                    PLpgSQL_var *var = (PLpgSQL_var *) d;
 
                    printf("VAR %-16s type %s (typoid %u) atttypmod %d\n",
                           var->refname, var->datatype->typname,
                           var->datatype->typoid,
                           var->datatype->atttypmod);
                    if (var->isconst)
                        printf("                                  CONSTANT\n");
                    if (var->notnull)
                        printf("                                  NOT NULL\n");
                    if (var->default_val != NULL)
                    {
                        printf("                                  DEFAULT ");
                        dump_expr(var->default_val);
                        printf("\n");
                    }
                    if (var->cursor_explicit_expr != NULL)
                    {
                        if (var->cursor_explicit_argrow >= 0)
                            printf("                                  CURSOR argument row %d\n", var->cursor_explicit_argrow);
 
                        printf("                                  CURSOR IS ");
                        dump_expr(var->cursor_explicit_expr);
                        printf("\n");
                    }
                    if (var->promise != PLPGSQL_PROMISE_NONE)
                        printf("                                  PROMISE %d\n",
                               (int) var->promise);
                }
                break;
            case PLPGSQL_DTYPE_ROW:
                {
                    PLpgSQL_row *row = (PLpgSQL_row *) d;
 
                    printf("ROW %-16s fields", row->refname);
                    for (int j = 0; j < row->nfields; j++)
                    {
                        printf(" %s=var %d", row->fieldnames[j],
                               row->varnos[j]);
                    }
                    printf("\n");
                }
                break;
            case PLPGSQL_DTYPE_REC:
                printf("REC %-16s typoid %u\n",
                       ((PLpgSQL_rec *) d)->refname,
                       ((PLpgSQL_rec *) d)->rectypeid);
                if (((PLpgSQL_rec *) d)->isconst)
                    printf("                                  CONSTANT\n");
                if (((PLpgSQL_rec *) d)->notnull)
                    printf("                                  NOT NULL\n");
                if (((PLpgSQL_rec *) d)->default_val != NULL)
                {
                    printf("                                  DEFAULT ");
                    dump_expr(((PLpgSQL_rec *) d)->default_val);
                    printf("\n");
                }
                break;
            case PLPGSQL_DTYPE_RECFIELD:
                printf("RECFIELD %-16s of REC %d\n",
                       ((PLpgSQL_recfield *) d)->fieldname,
                       ((PLpgSQL_recfield *) d)->recparentno);
                break;
            default:
                printf("??? unknown data type %d\n", d->dtype);
        }
    }
    printf("\nFunction's statements:\n");
 
    dump_indent = 0;
    printf("%3d:", func->action->lineno);
    dump_block(func->action);
    printf("\nEnd of execution tree of function %s\n\n", func->fn_signature);
    fflush(stdout);
}

References PLpgSQL_function::action, PLpgSQL_type::atttypmod, PLpgSQL_var::cursor_explicit_argrow, PLpgSQL_var::cursor_explicit_expr, PLpgSQL_var::datatype, PLpgSQL_function::datums, PLpgSQL_var::default_val, PLpgSQL_datum::dtype, PLpgSQL_rec::dtype, dump_block(), dump_expr(), dump_indent, PLpgSQL_row::fieldnames, PLpgSQL_function::fn_signature, i, PLpgSQL_var::isconst, j, PLpgSQL_stmt_block::lineno, PLpgSQL_function::ndatums, PLpgSQL_row::nfields, PLpgSQL_var::notnull, PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_RECFIELD, PLPGSQL_DTYPE_ROW, PLPGSQL_DTYPE_VAR, PLPGSQL_PROMISE_NONE, printf, PLpgSQL_var::promise, PLpgSQL_var::refname, PLpgSQL_row::refname, generate_unaccent_rules::stdout, PLpgSQL_type::typname, PLpgSQL_type::typoid, and PLpgSQL_row::varnos.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_exec_event_trigger()

void plpgsql_exec_event_trigger	(	PLpgSQL_function *	func,
		EventTriggerData *	trigdata
	)

Definition at line 1175 of file pl_exec.c.

{
    PLpgSQL_execstate estate;
    ErrorContextCallback plerrcontext;
    int         rc;
 
    /*
     * Setup the execution state
     */
    plpgsql_estate_setup(&estate, func, NULL, NULL, NULL);
    estate.evtrigdata = trigdata;
 
    /*
     * Setup error traceback support for ereport()
     */
    plerrcontext.callback = plpgsql_exec_error_callback;
    plerrcontext.arg = &estate;
    plerrcontext.previous = error_context_stack;
    error_context_stack = &plerrcontext;
 
    /*
     * Make local execution copies of all the datums
     */
    estate.err_text = gettext_noop("during initialization of execution state");
    copy_plpgsql_datums(&estate, func);
 
    /*
     * Let the instrumentation plugin peek at this function
     */
    if (*plpgsql_plugin_ptr && (*plpgsql_plugin_ptr)->func_beg)
        ((*plpgsql_plugin_ptr)->func_beg) (&estate, func);
 
    /*
     * Now call the toplevel block of statements
     */
    estate.err_text = NULL;
    rc = exec_toplevel_block(&estate, func->action);
    if (rc != PLPGSQL_RC_RETURN)
    {
        estate.err_text = NULL;
        ereport(ERROR,
                (errcode(ERRCODE_S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT),
                 errmsg("control reached end of trigger procedure without RETURN")));
    }
 
    estate.err_text = gettext_noop("during function exit");
 
    /*
     * Let the instrumentation plugin peek at this function
     */
    if (*plpgsql_plugin_ptr && (*plpgsql_plugin_ptr)->func_end)
        ((*plpgsql_plugin_ptr)->func_end) (&estate, func);
 
    /* Clean up any leftover temporary memory */
    plpgsql_destroy_econtext(&estate);
    exec_eval_cleanup(&estate);
    /* stmt_mcontext will be destroyed when function's main context is */
 
    /*
     * Pop the error context stack
     */
    error_context_stack = plerrcontext.previous;
}

References PLpgSQL_function::action, ErrorContextCallback::arg, ErrorContextCallback::callback, copy_plpgsql_datums(), ereport, PLpgSQL_execstate::err_text, errcode(), errmsg(), ERROR, error_context_stack, PLpgSQL_execstate::evtrigdata, exec_eval_cleanup(), exec_toplevel_block(), PLpgSQL_plugin::func_beg, PLpgSQL_plugin::func_end, gettext_noop, plpgsql_destroy_econtext(), plpgsql_estate_setup(), plpgsql_exec_error_callback(), plpgsql_plugin_ptr, PLPGSQL_RC_RETURN, and ErrorContextCallback::previous.

Referenced by plpgsql_call_handler().

plpgsql_exec_function()

Datum plpgsql_exec_function	(	PLpgSQL_function *	func,
		FunctionCallInfo	fcinfo,
		EState *	simple_eval_estate,
		ResourceOwner	simple_eval_resowner,
		ResourceOwner	procedure_resowner,
		bool	atomic
	)

Definition at line 493 of file pl_exec.c.

{
    PLpgSQL_execstate estate;
    ErrorContextCallback plerrcontext;
    int         i;
    int         rc;
 
    /*
     * Setup the execution state
     */
    plpgsql_estate_setup(&estate, func, (ReturnSetInfo *) fcinfo->resultinfo,
                         simple_eval_estate, simple_eval_resowner);
    estate.procedure_resowner = procedure_resowner;
    estate.atomic = atomic;
 
    /*
     * Setup error traceback support for ereport()
     */
    plerrcontext.callback = plpgsql_exec_error_callback;
    plerrcontext.arg = &estate;
    plerrcontext.previous = error_context_stack;
    error_context_stack = &plerrcontext;
 
    /*
     * Make local execution copies of all the datums
     */
    estate.err_text = gettext_noop("during initialization of execution state");
    copy_plpgsql_datums(&estate, func);
 
    /*
     * Store the actual call argument values into the appropriate variables
     */
    estate.err_text = gettext_noop("while storing call arguments into local variables");
    for (i = 0; i < func->fn_nargs; i++)
    {
        int         n = func->fn_argvarnos[i];
 
        switch (estate.datums[n]->dtype)
        {
            case PLPGSQL_DTYPE_VAR:
                {
                    PLpgSQL_var *var = (PLpgSQL_var *) estate.datums[n];
 
                    assign_simple_var(&estate, var,
                                      fcinfo->args[i].value,
                                      fcinfo->args[i].isnull,
                                      false);
 
                    /*
                     * If it's a varlena type, check to see if we received a
                     * R/W expanded-object pointer.  If so, we can commandeer
                     * the object rather than having to copy it.  If passed a
                     * R/O expanded pointer, just keep it as the value of the
                     * variable for the moment.  (We can change it to R/W if
                     * the variable gets modified, but that may very well
                     * never happen.)
                     *
                     * Also, force any flat array value to be stored in
                     * expanded form in our local variable, in hopes of
                     * improving efficiency of uses of the variable.  (This is
                     * a hack, really: why only arrays? Need more thought
                     * about which cases are likely to win.  See also
                     * typisarray-specific heuristic in exec_assign_value.)
                     */
                    if (!var->isnull && var->datatype->typlen == -1)
                    {
                        if (VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(var->value)))
                        {
                            /* take ownership of R/W object */
                            assign_simple_var(&estate, var,
                                              TransferExpandedObject(var->value,
                                                                     estate.datum_context),
                                              false,
                                              true);
                        }
                        else if (VARATT_IS_EXTERNAL_EXPANDED_RO(DatumGetPointer(var->value)))
                        {
                            /* R/O pointer, keep it as-is until assigned to */
                        }
                        else if (var->datatype->typisarray)
                        {
                            /* flat array, so force to expanded form */
                            assign_simple_var(&estate, var,
                                              expand_array(var->value,
                                                           estate.datum_context,
                                                           NULL),
                                              false,
                                              true);
                        }
                    }
                }
                break;
 
            case PLPGSQL_DTYPE_REC:
                {
                    PLpgSQL_rec *rec = (PLpgSQL_rec *) estate.datums[n];
 
                    if (!fcinfo->args[i].isnull)
                    {
                        /* Assign row value from composite datum */
                        exec_move_row_from_datum(&estate,
                                                 (PLpgSQL_variable *) rec,
                                                 fcinfo->args[i].value);
                    }
                    else
                    {
                        /* If arg is null, set variable to null */
                        exec_move_row(&estate, (PLpgSQL_variable *) rec,
                                      NULL, NULL);
                    }
                    /* clean up after exec_move_row() */
                    exec_eval_cleanup(&estate);
                }
                break;
 
            default:
                /* Anything else should not be an argument variable */
                elog(ERROR, "unrecognized dtype: %d", func->datums[i]->dtype);
        }
    }
 
    estate.err_text = gettext_noop("during function entry");
 
    /*
     * Set the magic variable FOUND to false
     */
    exec_set_found(&estate, false);
 
    /*
     * Let the instrumentation plugin peek at this function
     */
    if (*plpgsql_plugin_ptr && (*plpgsql_plugin_ptr)->func_beg)
        ((*plpgsql_plugin_ptr)->func_beg) (&estate, func);
 
    /*
     * Now call the toplevel block of statements
     */
    estate.err_text = NULL;
    rc = exec_toplevel_block(&estate, func->action);
    if (rc != PLPGSQL_RC_RETURN)
    {
        estate.err_text = NULL;
        ereport(ERROR,
                (errcode(ERRCODE_S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT),
                 errmsg("control reached end of function without RETURN")));
    }
 
    /*
     * We got a return value - process it
     */
    estate.err_text = gettext_noop("while casting return value to function's return type");
 
    fcinfo->isnull = estate.retisnull;
 
    if (estate.retisset)
    {
        ReturnSetInfo *rsi = estate.rsi;
 
        /* Check caller can handle a set result */
        if (!rsi || !IsA(rsi, ReturnSetInfo))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("set-valued function called in context that cannot accept a set")));
 
        if (!(rsi->allowedModes & SFRM_Materialize))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("materialize mode required, but it is not allowed in this context")));
 
        rsi->returnMode = SFRM_Materialize;
 
        /* If we produced any tuples, send back the result */
        if (estate.tuple_store)
        {
            MemoryContext oldcxt;
 
            rsi->setResult = estate.tuple_store;
            oldcxt = MemoryContextSwitchTo(estate.tuple_store_cxt);
            rsi->setDesc = CreateTupleDescCopy(estate.tuple_store_desc);
            MemoryContextSwitchTo(oldcxt);
        }
        estate.retval = (Datum) 0;
        fcinfo->isnull = true;
    }
    else if (!estate.retisnull)
    {
        /*
         * Cast result value to function's declared result type, and copy it
         * out to the upper executor memory context.  We must treat tuple
         * results specially in order to deal with cases like rowtypes
         * involving dropped columns.
         */
        if (estate.retistuple)
        {
            /* Don't need coercion if rowtype is known to match */
            if (func->fn_rettype == estate.rettype &&
                func->fn_rettype != RECORDOID)
            {
                /*
                 * Copy the tuple result into upper executor memory context.
                 * However, if we have a R/W expanded datum, we can just
                 * transfer its ownership out to the upper context.
                 */
                estate.retval = SPI_datumTransfer(estate.retval,
                                                  false,
                                                  -1);
            }
            else
            {
                /*
                 * Need to look up the expected result type.  XXX would be
                 * better to cache the tupdesc instead of repeating
                 * get_call_result_type(), but the only easy place to save it
                 * is in the PLpgSQL_function struct, and that's too
                 * long-lived: composite types could change during the
                 * existence of a PLpgSQL_function.
                 */
                Oid         resultTypeId;
                TupleDesc   tupdesc;
 
                switch (get_call_result_type(fcinfo, &resultTypeId, &tupdesc))
                {
                    case TYPEFUNC_COMPOSITE:
                        /* got the expected result rowtype, now coerce it */
                        coerce_function_result_tuple(&estate, tupdesc);
                        break;
                    case TYPEFUNC_COMPOSITE_DOMAIN:
                        /* got the expected result rowtype, now coerce it */
                        coerce_function_result_tuple(&estate, tupdesc);
                        /* and check domain constraints */
                        /* XXX allowing caching here would be good, too */
                        domain_check(estate.retval, false, resultTypeId,
                                     NULL, NULL);
                        break;
                    case TYPEFUNC_RECORD:
 
                        /*
                         * Failed to determine actual type of RECORD.  We
                         * could raise an error here, but what this means in
                         * practice is that the caller is expecting any old
                         * generic rowtype, so we don't really need to be
                         * restrictive.  Pass back the generated result as-is.
                         */
                        estate.retval = SPI_datumTransfer(estate.retval,
                                                          false,
                                                          -1);
                        break;
                    default:
                        /* shouldn't get here if retistuple is true ... */
                        elog(ERROR, "return type must be a row type");
                        break;
                }
            }
        }
        else
        {
            /* Scalar case: use exec_cast_value */
            estate.retval = exec_cast_value(&estate,
                                            estate.retval,
                                            &fcinfo->isnull,
                                            estate.rettype,
                                            -1,
                                            func->fn_rettype,
                                            -1);
 
            /*
             * If the function's return type isn't by value, copy the value
             * into upper executor memory context.  However, if we have a R/W
             * expanded datum, we can just transfer its ownership out to the
             * upper executor context.
             */
            if (!fcinfo->isnull && !func->fn_retbyval)
                estate.retval = SPI_datumTransfer(estate.retval,
                                                  false,
                                                  func->fn_rettyplen);
        }
    }
    else
    {
        /*
         * We're returning a NULL, which normally requires no conversion work
         * regardless of datatypes.  But, if we are casting it to a domain
         * return type, we'd better check that the domain's constraints pass.
         */
        if (func->fn_retisdomain)
            estate.retval = exec_cast_value(&estate,
                                            estate.retval,
                                            &fcinfo->isnull,
                                            estate.rettype,
                                            -1,
                                            func->fn_rettype,
                                            -1);
    }
 
    estate.err_text = gettext_noop("during function exit");
 
    /*
     * Let the instrumentation plugin peek at this function
     */
    if (*plpgsql_plugin_ptr && (*plpgsql_plugin_ptr)->func_end)
        ((*plpgsql_plugin_ptr)->func_end) (&estate, func);
 
    /* Clean up any leftover temporary memory */
    plpgsql_destroy_econtext(&estate);
    exec_eval_cleanup(&estate);
    /* stmt_mcontext will be destroyed when function's main context is */
 
    /*
     * Pop the error context stack
     */
    error_context_stack = plerrcontext.previous;
 
    /*
     * Return the function's result
     */
    return estate.retval;
}

References PLpgSQL_function::action, ReturnSetInfo::allowedModes, ErrorContextCallback::arg, FunctionCallInfoBaseData::args, assign_simple_var(), PLpgSQL_execstate::atomic, ErrorContextCallback::callback, coerce_function_result_tuple(), copy_plpgsql_datums(), CreateTupleDescCopy(), PLpgSQL_var::datatype, PLpgSQL_execstate::datum_context, DatumGetPointer(), PLpgSQL_function::datums, PLpgSQL_execstate::datums, domain_check(), PLpgSQL_datum::dtype, elog, ereport, PLpgSQL_execstate::err_text, errcode(), errmsg(), ERROR, error_context_stack, exec_cast_value(), exec_eval_cleanup(), exec_move_row(), exec_move_row_from_datum(), exec_set_found(), exec_toplevel_block(), expand_array(), PLpgSQL_function::fn_argvarnos, PLpgSQL_function::fn_nargs, PLpgSQL_function::fn_retbyval, PLpgSQL_function::fn_retisdomain, PLpgSQL_function::fn_rettype, PLpgSQL_function::fn_rettyplen, PLpgSQL_plugin::func_beg, PLpgSQL_plugin::func_end, get_call_result_type(), gettext_noop, i, if(), IsA, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, PLpgSQL_var::isnull, MemoryContextSwitchTo(), plpgsql_destroy_econtext(), PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_VAR, plpgsql_estate_setup(), plpgsql_exec_error_callback(), plpgsql_plugin_ptr, PLPGSQL_RC_RETURN, ErrorContextCallback::previous, PLpgSQL_execstate::procedure_resowner, FunctionCallInfoBaseData::resultinfo, PLpgSQL_execstate::retisnull, PLpgSQL_execstate::retisset, PLpgSQL_execstate::retistuple, PLpgSQL_execstate::rettype, ReturnSetInfo::returnMode, PLpgSQL_execstate::retval, PLpgSQL_execstate::rsi, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SPI_datumTransfer(), TransferExpandedObject(), PLpgSQL_execstate::tuple_store, PLpgSQL_execstate::tuple_store_cxt, PLpgSQL_execstate::tuple_store_desc, TYPEFUNC_COMPOSITE, TYPEFUNC_COMPOSITE_DOMAIN, TYPEFUNC_RECORD, PLpgSQL_type::typisarray, PLpgSQL_type::typlen, NullableDatum::value, PLpgSQL_var::value, VARATT_IS_EXTERNAL_EXPANDED_RO(), and VARATT_IS_EXTERNAL_EXPANDED_RW().

Referenced by plpgsql_call_handler(), and plpgsql_inline_handler().

plpgsql_exec_get_datum_type()

PGDLLEXPORT Oid plpgsql_exec_get_datum_type	(	PLpgSQL_execstate *	estate,
		PLpgSQL_datum *	datum
	)

Definition at line 5453 of file pl_exec.c.

{
    Oid         typeid;
 
    switch (datum->dtype)
    {
        case PLPGSQL_DTYPE_VAR:
        case PLPGSQL_DTYPE_PROMISE:
            {
                PLpgSQL_var *var = (PLpgSQL_var *) datum;
 
                typeid = var->datatype->typoid;
                break;
            }
 
        case PLPGSQL_DTYPE_REC:
            {
                PLpgSQL_rec *rec = (PLpgSQL_rec *) datum;
 
                if (rec->erh == NULL || rec->rectypeid != RECORDOID)
                {
                    /* Report variable's declared type */
                    typeid = rec->rectypeid;
                }
                else
                {
                    /* Report record's actual type if declared RECORD */
                    typeid = rec->erh->er_typeid;
                }
                break;
            }
 
        case PLPGSQL_DTYPE_RECFIELD:
            {
                PLpgSQL_recfield *recfield = (PLpgSQL_recfield *) datum;
                PLpgSQL_rec *rec;
 
                rec = (PLpgSQL_rec *) (estate->datums[recfield->recparentno]);
 
                /*
                 * If record variable is NULL, instantiate it if it has a
                 * named composite type, else complain.  (This won't change
                 * the logical state of the record: it's still NULL.)
                 */
                if (rec->erh == NULL)
                    instantiate_empty_record_variable(estate, rec);
 
                /*
                 * Look up the field's properties if we have not already, or
                 * if the tuple descriptor ID changed since last time.
                 */
                if (unlikely(recfield->rectupledescid != rec->erh->er_tupdesc_id))
                {
                    if (!expanded_record_lookup_field(rec->erh,
                                                      recfield->fieldname,
                                                      &recfield->finfo))
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_COLUMN),
                                 errmsg("record \"%s\" has no field \"%s\"",
                                        rec->refname, recfield->fieldname)));
                    recfield->rectupledescid = rec->erh->er_tupdesc_id;
                }
 
                typeid = recfield->finfo.ftypeid;
                break;
            }
 
        default:
            elog(ERROR, "unrecognized dtype: %d", datum->dtype);
            typeid = InvalidOid;    /* keep compiler quiet */
            break;
    }
 
    return typeid;
}

References PLpgSQL_var::datatype, PLpgSQL_execstate::datums, PLpgSQL_datum::dtype, elog, ExpandedRecordHeader::er_tupdesc_id, ExpandedRecordHeader::er_typeid, ereport, PLpgSQL_rec::erh, errcode(), errmsg(), ERROR, expanded_record_lookup_field(), PLpgSQL_recfield::fieldname, PLpgSQL_recfield::finfo, ExpandedRecordFieldInfo::ftypeid, instantiate_empty_record_variable(), InvalidOid, PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_RECFIELD, PLPGSQL_DTYPE_VAR, PLpgSQL_recfield::recparentno, PLpgSQL_recfield::rectupledescid, PLpgSQL_rec::rectypeid, PLpgSQL_rec::refname, PLpgSQL_type::typoid, and unlikely.

Referenced by exec_stmt_foreach_a().

plpgsql_exec_get_datum_type_info()

void plpgsql_exec_get_datum_type_info	(	PLpgSQL_execstate *	estate,
		PLpgSQL_datum *	datum,
		Oid *	typeId,
		int32 *	typMod,
		Oid *	collation
	)

Definition at line 5538 of file pl_exec.c.

{
    switch (datum->dtype)
    {
        case PLPGSQL_DTYPE_VAR:
        case PLPGSQL_DTYPE_PROMISE:
            {
                PLpgSQL_var *var = (PLpgSQL_var *) datum;
 
                *typeId = var->datatype->typoid;
                *typMod = var->datatype->atttypmod;
                *collation = var->datatype->collation;
                break;
            }
 
        case PLPGSQL_DTYPE_REC:
            {
                PLpgSQL_rec *rec = (PLpgSQL_rec *) datum;
 
                if (rec->erh == NULL || rec->rectypeid != RECORDOID)
                {
                    /* Report variable's declared type */
                    *typeId = rec->rectypeid;
                    *typMod = -1;
                }
                else
                {
                    /* Report record's actual type if declared RECORD */
                    *typeId = rec->erh->er_typeid;
                    /* do NOT return the mutable typmod of a RECORD variable */
                    *typMod = -1;
                }
                /* composite types are never collatable */
                *collation = InvalidOid;
                break;
            }
 
        case PLPGSQL_DTYPE_RECFIELD:
            {
                PLpgSQL_recfield *recfield = (PLpgSQL_recfield *) datum;
                PLpgSQL_rec *rec;
 
                rec = (PLpgSQL_rec *) (estate->datums[recfield->recparentno]);
 
                /*
                 * If record variable is NULL, instantiate it if it has a
                 * named composite type, else complain.  (This won't change
                 * the logical state of the record: it's still NULL.)
                 */
                if (rec->erh == NULL)
                    instantiate_empty_record_variable(estate, rec);
 
                /*
                 * Look up the field's properties if we have not already, or
                 * if the tuple descriptor ID changed since last time.
                 */
                if (unlikely(recfield->rectupledescid != rec->erh->er_tupdesc_id))
                {
                    if (!expanded_record_lookup_field(rec->erh,
                                                      recfield->fieldname,
                                                      &recfield->finfo))
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_COLUMN),
                                 errmsg("record \"%s\" has no field \"%s\"",
                                        rec->refname, recfield->fieldname)));
                    recfield->rectupledescid = rec->erh->er_tupdesc_id;
                }
 
                *typeId = recfield->finfo.ftypeid;
                *typMod = recfield->finfo.ftypmod;
                *collation = recfield->finfo.fcollation;
                break;
            }
 
        default:
            elog(ERROR, "unrecognized dtype: %d", datum->dtype);
            *typeId = InvalidOid;   /* keep compiler quiet */
            *typMod = -1;
            *collation = InvalidOid;
            break;
    }
}

References PLpgSQL_type::atttypmod, PLpgSQL_type::collation, PLpgSQL_var::datatype, PLpgSQL_execstate::datums, PLpgSQL_datum::dtype, elog, ExpandedRecordHeader::er_tupdesc_id, ExpandedRecordHeader::er_typeid, ereport, PLpgSQL_rec::erh, errcode(), errmsg(), ERROR, expanded_record_lookup_field(), ExpandedRecordFieldInfo::fcollation, PLpgSQL_recfield::fieldname, PLpgSQL_recfield::finfo, ExpandedRecordFieldInfo::ftypeid, ExpandedRecordFieldInfo::ftypmod, instantiate_empty_record_variable(), InvalidOid, PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_RECFIELD, PLPGSQL_DTYPE_VAR, PLpgSQL_recfield::recparentno, PLpgSQL_recfield::rectupledescid, PLpgSQL_rec::rectypeid, PLpgSQL_rec::refname, PLpgSQL_type::typoid, and unlikely.

Referenced by make_datum_param().

plpgsql_exec_trigger()

HeapTuple plpgsql_exec_trigger	(	PLpgSQL_function *	func,
		TriggerData *	trigdata
	)

Definition at line 935 of file pl_exec.c.

{
    PLpgSQL_execstate estate;
    ErrorContextCallback plerrcontext;
    int         rc;
    TupleDesc   tupdesc;
    PLpgSQL_rec *rec_new,
               *rec_old;
    HeapTuple   rettup;
 
    /*
     * Setup the execution state
     */
    plpgsql_estate_setup(&estate, func, NULL, NULL, NULL);
    estate.trigdata = trigdata;
 
    /*
     * Setup error traceback support for ereport()
     */
    plerrcontext.callback = plpgsql_exec_error_callback;
    plerrcontext.arg = &estate;
    plerrcontext.previous = error_context_stack;
    error_context_stack = &plerrcontext;
 
    /*
     * Make local execution copies of all the datums
     */
    estate.err_text = gettext_noop("during initialization of execution state");
    copy_plpgsql_datums(&estate, func);
 
    /*
     * Put the OLD and NEW tuples into record variables
     *
     * We set up expanded records for both variables even though only one may
     * have a value.  This allows record references to succeed in functions
     * that are used for multiple trigger types.  For example, we might have a
     * test like "if (TG_OP = 'INSERT' and NEW.foo = 'xyz')", which should
     * work regardless of the current trigger type.  If a value is actually
     * fetched from an unsupplied tuple, it will read as NULL.
     */
    tupdesc = RelationGetDescr(trigdata->tg_relation);
 
    rec_new = (PLpgSQL_rec *) (estate.datums[func->new_varno]);
    rec_old = (PLpgSQL_rec *) (estate.datums[func->old_varno]);
 
    rec_new->erh = make_expanded_record_from_tupdesc(tupdesc,
                                                     estate.datum_context);
    rec_old->erh = make_expanded_record_from_exprecord(rec_new->erh,
                                                       estate.datum_context);
 
    if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
    {
        /*
         * Per-statement triggers don't use OLD/NEW variables
         */
    }
    else if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
    {
        expanded_record_set_tuple(rec_new->erh, trigdata->tg_trigtuple,
                                  false, false);
    }
    else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
    {
        expanded_record_set_tuple(rec_new->erh, trigdata->tg_newtuple,
                                  false, false);
        expanded_record_set_tuple(rec_old->erh, trigdata->tg_trigtuple,
                                  false, false);
 
        /*
         * In BEFORE trigger, stored generated columns are not computed yet,
         * so make them null in the NEW row.  (Only needed in UPDATE branch;
         * in the INSERT case, they are already null, but in UPDATE, the field
         * still contains the old value.)  Alternatively, we could construct a
         * whole new row structure without the generated columns, but this way
         * seems more efficient and potentially less confusing.
         */
        if (tupdesc->constr && tupdesc->constr->has_generated_stored &&
            TRIGGER_FIRED_BEFORE(trigdata->tg_event))
        {
            for (int i = 0; i < tupdesc->natts; i++)
                if (TupleDescAttr(tupdesc, i)->attgenerated == ATTRIBUTE_GENERATED_STORED)
                    expanded_record_set_field_internal(rec_new->erh,
                                                       i + 1,
                                                       (Datum) 0,
                                                       true,    /* isnull */
                                                       false, false);
        }
    }
    else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
    {
        expanded_record_set_tuple(rec_old->erh, trigdata->tg_trigtuple,
                                  false, false);
    }
    else
        elog(ERROR, "unrecognized trigger action: not INSERT, DELETE, or UPDATE");
 
    /* Make transition tables visible to this SPI connection */
    rc = SPI_register_trigger_data(trigdata);
    Assert(rc >= 0);
 
    estate.err_text = gettext_noop("during function entry");
 
    /*
     * Set the magic variable FOUND to false
     */
    exec_set_found(&estate, false);
 
    /*
     * Let the instrumentation plugin peek at this function
     */
    if (*plpgsql_plugin_ptr && (*plpgsql_plugin_ptr)->func_beg)
        ((*plpgsql_plugin_ptr)->func_beg) (&estate, func);
 
    /*
     * Now call the toplevel block of statements
     */
    estate.err_text = NULL;
    rc = exec_toplevel_block(&estate, func->action);
    if (rc != PLPGSQL_RC_RETURN)
    {
        estate.err_text = NULL;
        ereport(ERROR,
                (errcode(ERRCODE_S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT),
                 errmsg("control reached end of trigger procedure without RETURN")));
    }
 
    estate.err_text = gettext_noop("during function exit");
 
    if (estate.retisset)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("trigger procedure cannot return a set")));
 
    /*
     * Check that the returned tuple structure has the same attributes, the
     * relation that fired the trigger has. A per-statement trigger always
     * needs to return NULL, so we ignore any return value the function itself
     * produces (XXX: is this a good idea?)
     *
     * XXX This way it is possible, that the trigger returns a tuple where
     * attributes don't have the correct atttypmod's length. It's up to the
     * trigger's programmer to ensure that this doesn't happen. Jan
     */
    if (estate.retisnull || !TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
        rettup = NULL;
    else
    {
        TupleDesc   retdesc;
        TupleConversionMap *tupmap;
 
        /* We assume exec_stmt_return verified that result is composite */
        Assert(type_is_rowtype(estate.rettype));
 
        /* We can special-case expanded records for speed */
        if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(estate.retval)))
        {
            ExpandedRecordHeader *erh = (ExpandedRecordHeader *) DatumGetEOHP(estate.retval);
 
            Assert(erh->er_magic == ER_MAGIC);
 
            /* Extract HeapTuple and TupleDesc */
            rettup = expanded_record_get_tuple(erh);
            Assert(rettup);
            retdesc = expanded_record_get_tupdesc(erh);
 
            if (retdesc != RelationGetDescr(trigdata->tg_relation))
            {
                /* check rowtype compatibility */
                tupmap = convert_tuples_by_position(retdesc,
                                                    RelationGetDescr(trigdata->tg_relation),
                                                    gettext_noop("returned row structure does not match the structure of the triggering table"));
                /* it might need conversion */
                if (tupmap)
                    rettup = execute_attr_map_tuple(rettup, tupmap);
                /* no need to free map, we're about to return anyway */
            }
 
            /*
             * Copy tuple to upper executor memory.  But if user just did
             * "return new" or "return old" without changing anything, there's
             * no need to copy; we can return the original tuple (which will
             * save a few cycles in trigger.c as well as here).
             */
            if (rettup != trigdata->tg_newtuple &&
                rettup != trigdata->tg_trigtuple)
                rettup = SPI_copytuple(rettup);
        }
        else
        {
            /* Convert composite datum to a HeapTuple and TupleDesc */
            HeapTupleData tmptup;
 
            retdesc = deconstruct_composite_datum(estate.retval, &tmptup);
            rettup = &tmptup;
 
            /* check rowtype compatibility */
            tupmap = convert_tuples_by_position(retdesc,
                                                RelationGetDescr(trigdata->tg_relation),
                                                gettext_noop("returned row structure does not match the structure of the triggering table"));
            /* it might need conversion */
            if (tupmap)
                rettup = execute_attr_map_tuple(rettup, tupmap);
 
            ReleaseTupleDesc(retdesc);
            /* no need to free map, we're about to return anyway */
 
            /* Copy tuple to upper executor memory */
            rettup = SPI_copytuple(rettup);
        }
    }
 
    /*
     * Let the instrumentation plugin peek at this function
     */
    if (*plpgsql_plugin_ptr && (*plpgsql_plugin_ptr)->func_end)
        ((*plpgsql_plugin_ptr)->func_end) (&estate, func);
 
    /* Clean up any leftover temporary memory */
    plpgsql_destroy_econtext(&estate);
    exec_eval_cleanup(&estate);
    /* stmt_mcontext will be destroyed when function's main context is */
 
    /*
     * Pop the error context stack
     */
    error_context_stack = plerrcontext.previous;
 
    /*
     * Return the trigger's result
     */
    return rettup;
}

References PLpgSQL_function::action, ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, TupleDescData::constr, convert_tuples_by_position(), copy_plpgsql_datums(), PLpgSQL_execstate::datum_context, DatumGetEOHP(), DatumGetPointer(), PLpgSQL_execstate::datums, deconstruct_composite_datum(), elog, ER_MAGIC, ExpandedRecordHeader::er_magic, ereport, PLpgSQL_rec::erh, PLpgSQL_execstate::err_text, errcode(), errmsg(), ERROR, error_context_stack, exec_eval_cleanup(), exec_set_found(), exec_toplevel_block(), execute_attr_map_tuple(), expanded_record_get_tupdesc(), expanded_record_get_tuple(), expanded_record_set_field_internal(), expanded_record_set_tuple(), PLpgSQL_plugin::func_beg, PLpgSQL_plugin::func_end, gettext_noop, TupleConstr::has_generated_stored, i, make_expanded_record_from_exprecord(), make_expanded_record_from_tupdesc(), TupleDescData::natts, PLpgSQL_function::new_varno, PLpgSQL_function::old_varno, plpgsql_destroy_econtext(), plpgsql_estate_setup(), plpgsql_exec_error_callback(), plpgsql_plugin_ptr, PLPGSQL_RC_RETURN, ErrorContextCallback::previous, RelationGetDescr, ReleaseTupleDesc, PLpgSQL_execstate::retisnull, PLpgSQL_execstate::retisset, PLpgSQL_execstate::rettype, PLpgSQL_execstate::retval, SPI_copytuple(), SPI_register_trigger_data(), TriggerData::tg_event, TriggerData::tg_newtuple, TriggerData::tg_relation, TriggerData::tg_trigtuple, PLpgSQL_execstate::trigdata, TRIGGER_FIRED_BEFORE, TRIGGER_FIRED_BY_DELETE, TRIGGER_FIRED_BY_INSERT, TRIGGER_FIRED_BY_UPDATE, TRIGGER_FIRED_FOR_ROW, TupleDescAttr(), type_is_rowtype(), and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by plpgsql_call_handler().

plpgsql_free_function_memory()

void plpgsql_free_function_memory

(

PLpgSQL_function *

func

)

Definition at line 716 of file pl_funcs.c.

{
    int         i;
 
    /* Better not call this on an in-use function */
    Assert(func->cfunc.use_count == 0);
 
    /* Release plans associated with variable declarations */
    for (i = 0; i < func->ndatums; i++)
    {
        PLpgSQL_datum *d = func->datums[i];
 
        switch (d->dtype)
        {
            case PLPGSQL_DTYPE_VAR:
            case PLPGSQL_DTYPE_PROMISE:
                {
                    PLpgSQL_var *var = (PLpgSQL_var *) d;
 
                    free_expr(var->default_val, NULL);
                    free_expr(var->cursor_explicit_expr, NULL);
                }
                break;
            case PLPGSQL_DTYPE_ROW:
                break;
            case PLPGSQL_DTYPE_REC:
                {
                    PLpgSQL_rec *rec = (PLpgSQL_rec *) d;
 
                    free_expr(rec->default_val, NULL);
                }
                break;
            case PLPGSQL_DTYPE_RECFIELD:
                break;
            default:
                elog(ERROR, "unrecognized data type: %d", d->dtype);
        }
    }
    func->ndatums = 0;
 
    /* Release plans in statement tree */
    free_stmt((PLpgSQL_stmt *) func->action, NULL);
    func->action = NULL;
 
    /*
     * And finally, release all memory except the PLpgSQL_function struct
     * itself (which has to be kept around because there may be multiple
     * fn_extra pointers to it).
     */
    if (func->fn_cxt)
        MemoryContextDelete(func->fn_cxt);
    func->fn_cxt = NULL;
}

References PLpgSQL_function::action, Assert(), PLpgSQL_function::cfunc, PLpgSQL_var::cursor_explicit_expr, PLpgSQL_function::datums, PLpgSQL_var::default_val, PLpgSQL_rec::default_val, PLpgSQL_datum::dtype, elog, ERROR, PLpgSQL_function::fn_cxt, free_expr(), free_stmt(), i, MemoryContextDelete(), PLpgSQL_function::ndatums, PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_RECFIELD, PLPGSQL_DTYPE_ROW, PLPGSQL_DTYPE_VAR, and CachedFunction::use_count.

Referenced by plpgsql_delete_callback(), and plpgsql_inline_handler().

plpgsql_getdiag_kindname()

const char * plpgsql_getdiag_kindname

(

PLpgSQL_getdiag_kind

kind

)

Definition at line 300 of file pl_funcs.c.

{
    switch (kind)
    {
        case PLPGSQL_GETDIAG_ROW_COUNT:
            return "ROW_COUNT";
        case PLPGSQL_GETDIAG_ROUTINE_OID:
            return "PG_ROUTINE_OID";
        case PLPGSQL_GETDIAG_CONTEXT:
            return "PG_CONTEXT";
        case PLPGSQL_GETDIAG_ERROR_CONTEXT:
            return "PG_EXCEPTION_CONTEXT";
        case PLPGSQL_GETDIAG_ERROR_DETAIL:
            return "PG_EXCEPTION_DETAIL";
        case PLPGSQL_GETDIAG_ERROR_HINT:
            return "PG_EXCEPTION_HINT";
        case PLPGSQL_GETDIAG_RETURNED_SQLSTATE:
            return "RETURNED_SQLSTATE";
        case PLPGSQL_GETDIAG_COLUMN_NAME:
            return "COLUMN_NAME";
        case PLPGSQL_GETDIAG_CONSTRAINT_NAME:
            return "CONSTRAINT_NAME";
        case PLPGSQL_GETDIAG_DATATYPE_NAME:
            return "PG_DATATYPE_NAME";
        case PLPGSQL_GETDIAG_MESSAGE_TEXT:
            return "MESSAGE_TEXT";
        case PLPGSQL_GETDIAG_TABLE_NAME:
            return "TABLE_NAME";
        case PLPGSQL_GETDIAG_SCHEMA_NAME:
            return "SCHEMA_NAME";
    }
 
    return "unknown";
}

References PLPGSQL_GETDIAG_COLUMN_NAME, PLPGSQL_GETDIAG_CONSTRAINT_NAME, PLPGSQL_GETDIAG_CONTEXT, PLPGSQL_GETDIAG_DATATYPE_NAME, PLPGSQL_GETDIAG_ERROR_CONTEXT, PLPGSQL_GETDIAG_ERROR_DETAIL, PLPGSQL_GETDIAG_ERROR_HINT, PLPGSQL_GETDIAG_MESSAGE_TEXT, PLPGSQL_GETDIAG_RETURNED_SQLSTATE, PLPGSQL_GETDIAG_ROUTINE_OID, PLPGSQL_GETDIAG_ROW_COUNT, PLPGSQL_GETDIAG_SCHEMA_NAME, and PLPGSQL_GETDIAG_TABLE_NAME.

Referenced by dump_getdiag().

plpgsql_latest_lineno()

int plpgsql_latest_lineno

(

yyscan_t

yyscanner

)

Definition at line 607 of file pl_scanner.c.

{
    return yyextra->cur_line_num;
}

References yyextra.

Referenced by plpgsql_compile_error_callback().

plpgsql_location_to_lineno()

int plpgsql_location_to_lineno	(	int	location,
		yyscan_t	yyscanner
	)

Definition at line 573 of file pl_scanner.c.

{
    const char *loc;
 
    if (location < 0 || yyextra->scanorig == NULL)
        return 0;               /* garbage in, garbage out */
    loc = yyextra->scanorig + location;
 
    /* be correct, but not fast, if input location goes backwards */
    if (loc < yyextra->cur_line_start)
        location_lineno_init(yyscanner);
 
    while (yyextra->cur_line_end != NULL && loc > yyextra->cur_line_end)
    {
        yyextra->cur_line_start = yyextra->cur_line_end + 1;
        yyextra->cur_line_num++;
        yyextra->cur_line_end = strchr(yyextra->cur_line_start, '\n');
    }
 
    return yyextra->cur_line_num;
}

References plpgsql_yy_extra_type::cur_line_start, location_lineno_init(), plpgsql_yy_extra_type::scanorig, and yyextra.

plpgsql_mark_local_assignment_targets()

void plpgsql_mark_local_assignment_targets

(

PLpgSQL_function *

func

)

Definition at line 673 of file pl_funcs.c.

{
    Bitmapset  *local_dnos;
 
    /* Function parameters can be treated as local targets at outer level */
    local_dnos = NULL;
    for (int i = 0; i < func->fn_nargs; i++)
        local_dnos = bms_add_member(local_dnos, func->fn_argvarnos[i]);
    mark_stmt((PLpgSQL_stmt *) func->action, local_dnos);
    bms_free(local_dnos);
}

References PLpgSQL_function::action, bms_add_member(), bms_free(), PLpgSQL_function::fn_argvarnos, PLpgSQL_function::fn_nargs, i, and mark_stmt().

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_ns_additem()

void plpgsql_ns_additem	(	PLpgSQL_nsitem_type	itemtype,
		int	itemno,
		const char *	name
	)

Definition at line 92 of file pl_funcs.c.

{
    PLpgSQL_nsitem *nse;
 
    Assert(name != NULL);
    /* first item added must be a label */
    Assert(ns_top != NULL || itemtype == PLPGSQL_NSTYPE_LABEL);
 
    nse = palloc(offsetof(PLpgSQL_nsitem, name) + strlen(name) + 1);
    nse->itemtype = itemtype;
    nse->itemno = itemno;
    nse->prev = ns_top;
    strcpy(nse->name, name);
    ns_top = nse;
}

References Assert(), PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, name, PLpgSQL_nsitem::name, ns_top, palloc(), PLPGSQL_NSTYPE_LABEL, and PLpgSQL_nsitem::prev.

Referenced by add_parameter_name(), plpgsql_build_record(), plpgsql_build_variable(), and plpgsql_ns_push().

plpgsql_ns_find_nearest_loop()

PLpgSQL_nsitem * plpgsql_ns_find_nearest_loop

(

PLpgSQL_nsitem *

ns_cur

)

Definition at line 214 of file pl_funcs.c.

{
    while (ns_cur != NULL)
    {
        if (ns_cur->itemtype == PLPGSQL_NSTYPE_LABEL &&
            ns_cur->itemno == PLPGSQL_LABEL_LOOP)
            return ns_cur;
        ns_cur = ns_cur->prev;
    }
 
    return NULL;                /* no loop found */
}

References PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, PLPGSQL_LABEL_LOOP, PLPGSQL_NSTYPE_LABEL, and PLpgSQL_nsitem::prev.

plpgsql_ns_init()

void plpgsql_ns_init

(

void

)

Definition at line 43 of file pl_funcs.c.

{
    ns_top = NULL;
}

References ns_top.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_ns_lookup()

PGDLLEXPORT PLpgSQL_nsitem * plpgsql_ns_lookup	(	PLpgSQL_nsitem *	ns_cur,
		bool	localmode,
		const char *	name1,
		const char *	name2,
		const char *	name3,
		int *	names_used
	)

Definition at line 130 of file pl_funcs.c.

{
    /* Outer loop iterates once per block level in the namespace chain */
    while (ns_cur != NULL)
    {
        PLpgSQL_nsitem *nsitem;
 
        /* Check this level for unqualified match to variable name */
        for (nsitem = ns_cur;
             nsitem->itemtype != PLPGSQL_NSTYPE_LABEL;
             nsitem = nsitem->prev)
        {
            if (strcmp(nsitem->name, name1) == 0)
            {
                if (name2 == NULL ||
                    nsitem->itemtype != PLPGSQL_NSTYPE_VAR)
                {
                    if (names_used)
                        *names_used = 1;
                    return nsitem;
                }
            }
        }
 
        /* Check this level for qualified match to variable name */
        if (name2 != NULL &&
            strcmp(nsitem->name, name1) == 0)
        {
            for (nsitem = ns_cur;
                 nsitem->itemtype != PLPGSQL_NSTYPE_LABEL;
                 nsitem = nsitem->prev)
            {
                if (strcmp(nsitem->name, name2) == 0)
                {
                    if (name3 == NULL ||
                        nsitem->itemtype != PLPGSQL_NSTYPE_VAR)
                    {
                        if (names_used)
                            *names_used = 2;
                        return nsitem;
                    }
                }
            }
        }
 
        if (localmode)
            break;              /* do not look into upper levels */
 
        ns_cur = nsitem->prev;
    }
 
    /* This is just to suppress possibly-uninitialized-variable warnings */
    if (names_used)
        *names_used = 0;
    return NULL;                /* No match found */
}

References PLpgSQL_nsitem::itemtype, PLpgSQL_nsitem::name, PLPGSQL_NSTYPE_LABEL, PLPGSQL_NSTYPE_VAR, and PLpgSQL_nsitem::prev.

Referenced by add_parameter_name(), plpgsql_param_ref(), plpgsql_parse_cwordtype(), plpgsql_parse_dblword(), plpgsql_parse_tripword(), plpgsql_parse_word(), plpgsql_parse_wordtype(), and resolve_column_ref().

plpgsql_ns_lookup_label()

PLpgSQL_nsitem * plpgsql_ns_lookup_label	(	PLpgSQL_nsitem *	ns_cur,
		const char *	name
	)

Definition at line 195 of file pl_funcs.c.

{
    while (ns_cur != NULL)
    {
        if (ns_cur->itemtype == PLPGSQL_NSTYPE_LABEL &&
            strcmp(ns_cur->name, name) == 0)
            return ns_cur;
        ns_cur = ns_cur->prev;
    }
 
    return NULL;                /* label not found */
}

References PLpgSQL_nsitem::itemtype, name, PLpgSQL_nsitem::name, PLPGSQL_NSTYPE_LABEL, and PLpgSQL_nsitem::prev.

plpgsql_ns_pop()

void plpgsql_ns_pop

(

void

)

Definition at line 67 of file pl_funcs.c.

{
    Assert(ns_top != NULL);
    while (ns_top->itemtype != PLPGSQL_NSTYPE_LABEL)
        ns_top = ns_top->prev;
    ns_top = ns_top->prev;
}

References Assert(), PLpgSQL_nsitem::itemtype, ns_top, PLPGSQL_NSTYPE_LABEL, and PLpgSQL_nsitem::prev.

plpgsql_ns_push()

void plpgsql_ns_push	(	const char *	label,
		PLpgSQL_label_type	label_type
	)

Definition at line 54 of file pl_funcs.c.

{
    if (label == NULL)
        label = "";
    plpgsql_ns_additem(PLPGSQL_NSTYPE_LABEL, (int) label_type, label);
}

References label, plpgsql_ns_additem(), and PLPGSQL_NSTYPE_LABEL.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_ns_top()

PLpgSQL_nsitem * plpgsql_ns_top

(

void

)

Definition at line 81 of file pl_funcs.c.

{
    return ns_top;
}

References ns_top.

Referenced by add_parameter_name(), plpgsql_parse_cwordtype(), plpgsql_parse_dblword(), plpgsql_parse_tripword(), plpgsql_parse_word(), and plpgsql_parse_wordtype().

plpgsql_parse_cwordrowtype()

PLpgSQL_type * plpgsql_parse_cwordrowtype

(

List *

idents

)

Definition at line 1721 of file pl_comp.c.

{
    Oid         classOid;
    Oid         typOid;
    RangeVar   *relvar;
    TypeName   *typName;
    MemoryContext oldCxt;
 
    /*
     * As above, this is a relation lookup but could be a type lookup if we
     * weren't being backwards-compatible about error wording.
     */
 
    /* Avoid memory leaks in long-term function context */
    oldCxt = MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
 
    /* Look up relation name.  Can't lock it - we might not have privileges. */
    relvar = makeRangeVarFromNameList(idents);
    classOid = RangeVarGetRelid(relvar, NoLock, false);
 
    /* Some relkinds lack type OIDs */
    typOid = get_rel_type_id(classOid);
    if (!OidIsValid(typOid))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("relation \"%s\" does not have a composite type",
                        relvar->relname)));
 
    typName = makeTypeNameFromNameList(idents);
 
    MemoryContextSwitchTo(oldCxt);
 
    /* Build and return the row type struct */
    return plpgsql_build_datatype(typOid, -1, InvalidOid, typName);
}

References ereport, errcode(), errmsg(), ERROR, get_rel_type_id(), InvalidOid, makeRangeVarFromNameList(), makeTypeNameFromNameList(), MemoryContextSwitchTo(), NoLock, OidIsValid, plpgsql_build_datatype(), plpgsql_compile_tmp_cxt, RangeVarGetRelid, and RangeVar::relname.

plpgsql_parse_cwordtype()

PLpgSQL_type * plpgsql_parse_cwordtype

(

List *

idents

)

Definition at line 1564 of file pl_comp.c.

{
    PLpgSQL_type *dtype = NULL;
    PLpgSQL_nsitem *nse;
    int         nnames;
    RangeVar   *relvar = NULL;
    const char *fldname = NULL;
    Oid         classOid;
    HeapTuple   attrtup = NULL;
    HeapTuple   typetup = NULL;
    Form_pg_attribute attrStruct;
    MemoryContext oldCxt;
 
    /* Avoid memory leaks in the long-term function context */
    oldCxt = MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
 
    if (list_length(idents) == 2)
    {
        /*
         * Do a lookup in the current namespace stack
         */
        nse = plpgsql_ns_lookup(plpgsql_ns_top(), false,
                                strVal(linitial(idents)),
                                strVal(lsecond(idents)),
                                NULL,
                                &nnames);
 
        if (nse != NULL && nse->itemtype == PLPGSQL_NSTYPE_VAR)
        {
            /* Block-qualified reference to scalar variable. */
            dtype = ((PLpgSQL_var *) (plpgsql_Datums[nse->itemno]))->datatype;
            goto done;
        }
        else if (nse != NULL && nse->itemtype == PLPGSQL_NSTYPE_REC &&
                 nnames == 2)
        {
            /* Block-qualified reference to record variable. */
            dtype = ((PLpgSQL_rec *) (plpgsql_Datums[nse->itemno]))->datatype;
            goto done;
        }
 
        /*
         * First word could also be a table name
         */
        relvar = makeRangeVar(NULL,
                              strVal(linitial(idents)),
                              -1);
        fldname = strVal(lsecond(idents));
    }
    else
    {
        /*
         * We could check for a block-qualified reference to a field of a
         * record variable, but %TYPE is documented as applying to variables,
         * not fields of variables.  Things would get rather ambiguous if we
         * allowed either interpretation.
         */
        List       *rvnames;
 
        Assert(list_length(idents) > 2);
        rvnames = list_delete_last(list_copy(idents));
        relvar = makeRangeVarFromNameList(rvnames);
        fldname = strVal(llast(idents));
    }
 
    /* Look up relation name.  Can't lock it - we might not have privileges. */
    classOid = RangeVarGetRelid(relvar, NoLock, false);
 
    /*
     * Fetch the named table field and its type
     */
    attrtup = SearchSysCacheAttName(classOid, fldname);
    if (!HeapTupleIsValid(attrtup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column \"%s\" of relation \"%s\" does not exist",
                        fldname, relvar->relname)));
    attrStruct = (Form_pg_attribute) GETSTRUCT(attrtup);
 
    typetup = SearchSysCache1(TYPEOID,
                              ObjectIdGetDatum(attrStruct->atttypid));
    if (!HeapTupleIsValid(typetup))
        elog(ERROR, "cache lookup failed for type %u", attrStruct->atttypid);
 
    /*
     * Found that - build a compiler type struct in the caller's cxt and
     * return it.  Note that we treat the type as being found-by-OID; no
     * attempt to re-look-up the type name will happen during invalidations.
     */
    MemoryContextSwitchTo(oldCxt);
    dtype = build_datatype(typetup,
                           attrStruct->atttypmod,
                           attrStruct->attcollation,
                           NULL);
    MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
 
done:
    if (HeapTupleIsValid(attrtup))
        ReleaseSysCache(attrtup);
    if (HeapTupleIsValid(typetup))
        ReleaseSysCache(typetup);
 
    MemoryContextSwitchTo(oldCxt);
    return dtype;
}

References Assert(), build_datatype(), elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT(), HeapTupleIsValid, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, linitial, list_copy(), list_delete_last(), list_length(), llast, lsecond, makeRangeVar(), makeRangeVarFromNameList(), MemoryContextSwitchTo(), NoLock, ObjectIdGetDatum(), plpgsql_compile_tmp_cxt, plpgsql_Datums, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, RangeVarGetRelid, ReleaseSysCache(), RangeVar::relname, SearchSysCache1(), SearchSysCacheAttName(), and strVal.

plpgsql_parse_dblword()

bool plpgsql_parse_dblword	(	char *	word1,
		char *	word2,
		PLwdatum *	wdatum,
		PLcword *	cword
	)

Definition at line 1358 of file pl_comp.c.

{
    PLpgSQL_nsitem *ns;
    List       *idents;
    int         nnames;
 
    idents = list_make2(makeString(word1),
                        makeString(word2));
 
    /*
     * We should do nothing in DECLARE sections.  In SQL expressions, we
     * really only need to make sure that RECFIELD datums are created when
     * needed.  In all the cases handled by this function, returning a T_DATUM
     * with a two-word idents string is the right thing.
     */
    if (plpgsql_IdentifierLookup != IDENTIFIER_LOOKUP_DECLARE)
    {
        /*
         * Do a lookup in the current namespace stack
         */
        ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
                               word1, word2, NULL,
                               &nnames);
        if (ns != NULL)
        {
            switch (ns->itemtype)
            {
                case PLPGSQL_NSTYPE_VAR:
                    /* Block-qualified reference to scalar variable. */
                    wdatum->datum = plpgsql_Datums[ns->itemno];
                    wdatum->ident = NULL;
                    wdatum->quoted = false; /* not used */
                    wdatum->idents = idents;
                    return true;
 
                case PLPGSQL_NSTYPE_REC:
                    if (nnames == 1)
                    {
                        /*
                         * First word is a record name, so second word could
                         * be a field in this record.  We build a RECFIELD
                         * datum whether it is or not --- any error will be
                         * detected later.
                         */
                        PLpgSQL_rec *rec;
                        PLpgSQL_recfield *new;
 
                        rec = (PLpgSQL_rec *) (plpgsql_Datums[ns->itemno]);
                        new = plpgsql_build_recfield(rec, word2);
 
                        wdatum->datum = (PLpgSQL_datum *) new;
                    }
                    else
                    {
                        /* Block-qualified reference to record variable. */
                        wdatum->datum = plpgsql_Datums[ns->itemno];
                    }
                    wdatum->ident = NULL;
                    wdatum->quoted = false; /* not used */
                    wdatum->idents = idents;
                    return true;
 
                default:
                    break;
            }
        }
    }
 
    /* Nothing found */
    cword->idents = idents;
    return false;
}

References PLwdatum::datum, PLwdatum::ident, IDENTIFIER_LOOKUP_DECLARE, PLcword::idents, PLwdatum::idents, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, list_make2, makeString(), plpgsql_build_recfield(), plpgsql_Datums, plpgsql_IdentifierLookup, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, and PLwdatum::quoted.

Referenced by plpgsql_yylex().

plpgsql_parse_err_condition()

PLpgSQL_condition * plpgsql_parse_err_condition

(

char *

condname

)

Definition at line 2174 of file pl_comp.c.

{
    int         i;
    PLpgSQL_condition *new;
    PLpgSQL_condition *prev;
 
    /*
     * XXX Eventually we will want to look for user-defined exception names
     * here.
     */
 
    if (strcmp(condname, "others") == 0)
    {
        new = palloc(sizeof(PLpgSQL_condition));
        new->sqlerrstate = PLPGSQL_OTHERS;
        new->condname = condname;
        new->next = NULL;
        return new;
    }
 
    prev = NULL;
    for (i = 0; exception_label_map[i].label != NULL; i++)
    {
        if (strcmp(condname, exception_label_map[i].label) == 0)
        {
            new = palloc(sizeof(PLpgSQL_condition));
            new->sqlerrstate = exception_label_map[i].sqlerrstate;
            new->condname = condname;
            new->next = prev;
            prev = new;
        }
    }
 
    if (!prev)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized exception condition \"%s\"",
                        condname)));
 
    return prev;
}

References ereport, errcode(), errmsg(), ERROR, exception_label_map, i, label, ExceptionLabelMap::label, palloc(), PLPGSQL_OTHERS, and ExceptionLabelMap::sqlerrstate.

plpgsql_parse_tripword()

bool plpgsql_parse_tripword	(	char *	word1,
		char *	word2,
		char *	word3,
		PLwdatum *	wdatum,
		PLcword *	cword
	)

Definition at line 1439 of file pl_comp.c.

{
    PLpgSQL_nsitem *ns;
    List       *idents;
    int         nnames;
 
    /*
     * We should do nothing in DECLARE sections.  In SQL expressions, we need
     * to make sure that RECFIELD datums are created when needed, and we need
     * to be careful about how many names are reported as belonging to the
     * T_DATUM: the third word could be a sub-field reference, which we don't
     * care about here.
     */
    if (plpgsql_IdentifierLookup != IDENTIFIER_LOOKUP_DECLARE)
    {
        /*
         * Do a lookup in the current namespace stack.  Must find a record
         * reference, else ignore.
         */
        ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
                               word1, word2, word3,
                               &nnames);
        if (ns != NULL)
        {
            switch (ns->itemtype)
            {
                case PLPGSQL_NSTYPE_REC:
                    {
                        PLpgSQL_rec *rec;
                        PLpgSQL_recfield *new;
 
                        rec = (PLpgSQL_rec *) (plpgsql_Datums[ns->itemno]);
                        if (nnames == 1)
                        {
                            /*
                             * First word is a record name, so second word
                             * could be a field in this record (and the third,
                             * a sub-field).  We build a RECFIELD datum
                             * whether it is or not --- any error will be
                             * detected later.
                             */
                            new = plpgsql_build_recfield(rec, word2);
                            idents = list_make2(makeString(word1),
                                                makeString(word2));
                        }
                        else
                        {
                            /* Block-qualified reference to record variable. */
                            new = plpgsql_build_recfield(rec, word3);
                            idents = list_make3(makeString(word1),
                                                makeString(word2),
                                                makeString(word3));
                        }
                        wdatum->datum = (PLpgSQL_datum *) new;
                        wdatum->ident = NULL;
                        wdatum->quoted = false; /* not used */
                        wdatum->idents = idents;
                        return true;
                    }
 
                default:
                    break;
            }
        }
    }
 
    /* Nothing found */
    idents = list_make3(makeString(word1),
                        makeString(word2),
                        makeString(word3));
    cword->idents = idents;
    return false;
}

References PLwdatum::datum, PLwdatum::ident, IDENTIFIER_LOOKUP_DECLARE, PLcword::idents, PLwdatum::idents, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, list_make2, list_make3, makeString(), plpgsql_build_recfield(), plpgsql_Datums, plpgsql_IdentifierLookup, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, and PLwdatum::quoted.

Referenced by plpgsql_yylex().

plpgsql_parse_word()

bool plpgsql_parse_word	(	char *	word1,
		const char *	yytxt,
		bool	lookup,
		PLwdatum *	wdatum,
		PLword *	word
	)

Definition at line 1303 of file pl_comp.c.

{
    PLpgSQL_nsitem *ns;
 
    /*
     * We should not lookup variables in DECLARE sections.  In SQL
     * expressions, there's no need to do so either --- lookup will happen
     * when the expression is compiled.
     */
    if (lookup && plpgsql_IdentifierLookup == IDENTIFIER_LOOKUP_NORMAL)
    {
        /*
         * Do a lookup in the current namespace stack
         */
        ns = plpgsql_ns_lookup(plpgsql_ns_top(), false,
                               word1, NULL, NULL,
                               NULL);
 
        if (ns != NULL)
        {
            switch (ns->itemtype)
            {
                case PLPGSQL_NSTYPE_VAR:
                case PLPGSQL_NSTYPE_REC:
                    wdatum->datum = plpgsql_Datums[ns->itemno];
                    wdatum->ident = word1;
                    wdatum->quoted = (yytxt[0] == '"');
                    wdatum->idents = NIL;
                    return true;
 
                default:
                    /* plpgsql_ns_lookup should never return anything else */
                    elog(ERROR, "unrecognized plpgsql itemtype: %d",
                         ns->itemtype);
            }
        }
    }
 
    /*
     * Nothing found - up to now it's a word without any special meaning for
     * us.
     */
    word->ident = word1;
    word->quoted = (yytxt[0] == '"');
    return false;
}

References PLwdatum::datum, elog, ERROR, PLwdatum::ident, IDENTIFIER_LOOKUP_NORMAL, PLwdatum::idents, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, NIL, plpgsql_Datums, plpgsql_IdentifierLookup, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, PLwdatum::quoted, and word().

Referenced by plpgsql_yylex().

plpgsql_parse_wordrowtype()

PLpgSQL_type * plpgsql_parse_wordrowtype

(

char *

ident

)

Definition at line 1676 of file pl_comp.c.

{
    Oid         classOid;
    Oid         typOid;
    TypeName   *typName;
    MemoryContext oldCxt;
 
    /* Avoid memory leaks in long-term function context */
    oldCxt = MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
 
    /*
     * Look up the relation.  Note that because relation rowtypes have the
     * same names as their relations, this could be handled as a type lookup
     * equally well; we use the relation lookup code path only because the
     * errors thrown here have traditionally referred to relations not types.
     * But we'll make a TypeName in case we have to do re-look-up of the type.
     */
    classOid = RelnameGetRelid(ident);
    if (!OidIsValid(classOid))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("relation \"%s\" does not exist", ident)));
 
    /* Some relkinds lack type OIDs */
    typOid = get_rel_type_id(classOid);
    if (!OidIsValid(typOid))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("relation \"%s\" does not have a composite type",
                        ident)));
 
    typName = makeTypeName(ident);
 
    MemoryContextSwitchTo(oldCxt);
 
    /* Build and return the row type struct */
    return plpgsql_build_datatype(typOid, -1, InvalidOid, typName);
}

References ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, get_rel_type_id(), ident, InvalidOid, makeTypeName(), MemoryContextSwitchTo(), OidIsValid, plpgsql_build_datatype(), plpgsql_compile_tmp_cxt, and RelnameGetRelid().

plpgsql_parse_wordtype()

PLpgSQL_type * plpgsql_parse_wordtype

(

char *

ident

)

Definition at line 1523 of file pl_comp.c.

{
    PLpgSQL_nsitem *nse;
 
    /*
     * Do a lookup in the current namespace stack
     */
    nse = plpgsql_ns_lookup(plpgsql_ns_top(), false,
                            ident, NULL, NULL,
                            NULL);
 
    if (nse != NULL)
    {
        switch (nse->itemtype)
        {
            case PLPGSQL_NSTYPE_VAR:
                return ((PLpgSQL_var *) (plpgsql_Datums[nse->itemno]))->datatype;
            case PLPGSQL_NSTYPE_REC:
                return ((PLpgSQL_rec *) (plpgsql_Datums[nse->itemno]))->datatype;
            default:
                break;
        }
    }
 
    /* No match, complain */
    ereport(ERROR,
            (errcode(ERRCODE_UNDEFINED_OBJECT),
             errmsg("variable \"%s\" does not exist", ident)));
    return NULL;                /* keep compiler quiet */
}

References ereport, errcode(), errmsg(), ERROR, ident, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, plpgsql_Datums, plpgsql_ns_lookup(), plpgsql_ns_top(), PLPGSQL_NSTYPE_REC, and PLPGSQL_NSTYPE_VAR.

plpgsql_parser_setup()

PGDLLEXPORT void plpgsql_parser_setup	(	struct ParseState *	pstate,
		PLpgSQL_expr *	expr
	)

Definition at line 989 of file pl_comp.c.

{
    pstate->p_pre_columnref_hook = plpgsql_pre_column_ref;
    pstate->p_post_columnref_hook = plpgsql_post_column_ref;
    pstate->p_paramref_hook = plpgsql_param_ref;
    /* no need to use p_coerce_param_hook */
    pstate->p_ref_hook_state = expr;
}

References ParseState::p_paramref_hook, ParseState::p_post_columnref_hook, ParseState::p_pre_columnref_hook, ParseState::p_ref_hook_state, plpgsql_param_ref(), plpgsql_post_column_ref(), and plpgsql_pre_column_ref().

Referenced by exec_prepare_plan(), and plpgsql_estate_setup().

plpgsql_peek()

int plpgsql_peek

(

yyscan_t

yyscanner

)

Definition at line 452 of file pl_scanner.c.

{
    int         tok1;
    TokenAuxData aux1;
 
    tok1 = internal_yylex(&aux1, yyscanner);
    push_back_token(tok1, &aux1, yyscanner);
    return tok1;
}

References internal_yylex(), and push_back_token().

plpgsql_peek2()

void plpgsql_peek2	(	int *	tok1_p,
		int *	tok2_p,
		int *	tok1_loc,
		int *	tok2_loc,
		yyscan_t	yyscanner
	)

Definition at line 471 of file pl_scanner.c.

{
    int         tok1,
                tok2;
    TokenAuxData aux1,
                aux2;
 
    tok1 = internal_yylex(&aux1, yyscanner);
    tok2 = internal_yylex(&aux2, yyscanner);
 
    *tok1_p = tok1;
    if (tok1_loc)
        *tok1_loc = aux1.lloc;
    *tok2_p = tok2;
    if (tok2_loc)
        *tok2_loc = aux2.lloc;
 
    push_back_token(tok2, &aux2, yyscanner);
    push_back_token(tok1, &aux1, yyscanner);
}

References internal_yylex(), TokenAuxData::lloc, and push_back_token().

plpgsql_push_back_token()

void plpgsql_push_back_token	(	int	token,
		union YYSTYPE *	yylvalp,
		YYLTYPE *	yyllocp,
		yyscan_t	yyscanner
	)

Definition at line 401 of file pl_scanner.c.

{
    TokenAuxData auxdata;
 
    auxdata.lval = *yylvalp;
    auxdata.lloc = *yyllocp;
    auxdata.leng = yyextra->plpgsql_yyleng;
    push_back_token(token, &auxdata, yyscanner);
}

References TokenAuxData::leng, TokenAuxData::lloc, TokenAuxData::lval, push_back_token(), and yyextra.

plpgsql_recognize_err_condition()

PGDLLEXPORT int plpgsql_recognize_err_condition	(	const char *	condname,
		bool	allow_sqlstate
	)

Definition at line 2138 of file pl_comp.c.

{
    int         i;
 
    if (allow_sqlstate)
    {
        if (strlen(condname) == 5 &&
            strspn(condname, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") == 5)
            return MAKE_SQLSTATE(condname[0],
                                 condname[1],
                                 condname[2],
                                 condname[3],
                                 condname[4]);
    }
 
    for (i = 0; exception_label_map[i].label != NULL; i++)
    {
        if (strcmp(condname, exception_label_map[i].label) == 0)
            return exception_label_map[i].sqlerrstate;
    }
 
    ereport(ERROR,
            (errcode(ERRCODE_UNDEFINED_OBJECT),
             errmsg("unrecognized exception condition \"%s\"",
                    condname)));
    return 0;                   /* keep compiler quiet */
}

References ereport, errcode(), errmsg(), ERROR, exception_label_map, i, label, ExceptionLabelMap::label, MAKE_SQLSTATE, and ExceptionLabelMap::sqlerrstate.

Referenced by exec_stmt_raise().

plpgsql_scanner_errposition()

int plpgsql_scanner_errposition	(	int	location,
		yyscan_t	yyscanner
	)

Definition at line 504 of file pl_scanner.c.

{
    int         pos;
 
    if (location < 0 || yyextra->scanorig == NULL)
        return 0;               /* no-op if location is unknown */
 
    /* Convert byte offset to character number */
    pos = pg_mbstrlen_with_len(yyextra->scanorig, location) + 1;
    /* And pass it to the ereport mechanism */
    (void) internalerrposition(pos);
    /* Also pass the function body string */
    return internalerrquery(yyextra->scanorig);
}

References internalerrposition(), internalerrquery(), pg_mbstrlen_with_len(), plpgsql_yy_extra_type::scanorig, and yyextra.

Referenced by plpgsql_yyerror().

plpgsql_scanner_finish()

void plpgsql_scanner_finish

(

yyscan_t

yyscanner

)

Definition at line 653 of file pl_scanner.c.

{
    /* release storage */
    scanner_finish(yyscanner);
}

References scanner_finish().

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_scanner_init()

yyscan_t plpgsql_scanner_init

(

const char *

str

)

Definition at line 621 of file pl_scanner.c.

{
    yyscan_t    yyscanner;
    struct plpgsql_yy_extra_type *yyext = palloc0_object(struct plpgsql_yy_extra_type);
 
    /* Start up the core scanner */
    yyscanner = scanner_init(str, (core_yy_extra_type *) yyext,
                             &ReservedPLKeywords, ReservedPLKeywordTokens);
 
    /*
     * scanorig points to the original string, which unlike the scanner's
     * scanbuf won't be modified on-the-fly by flex.  Notice that although
     * yytext points into scanbuf, we rely on being able to apply locations
     * (offsets from string start) to scanorig as well.
     */
    yyext->scanorig = str;
 
    /* Other setup */
    plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_NORMAL;
    yyext->plpgsql_yytoken = 0;
 
    yyext->num_pushbacks = 0;
 
    location_lineno_init(yyscanner);
 
    return yyscanner;
}

References IDENTIFIER_LOOKUP_NORMAL, location_lineno_init(), plpgsql_yy_extra_type::num_pushbacks, palloc0_object, plpgsql_IdentifierLookup, plpgsql_yy_extra_type::plpgsql_yytoken, ReservedPLKeywordTokens, scanner_init(), plpgsql_yy_extra_type::scanorig, and str.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_stmt_typename()

PGDLLEXPORT const char * plpgsql_stmt_typename

(

PLpgSQL_stmt *

stmt

)

Definition at line 232 of file pl_funcs.c.

{
    switch (stmt->cmd_type)
    {
        case PLPGSQL_STMT_BLOCK:
            return _("statement block");
        case PLPGSQL_STMT_ASSIGN:
            return _("assignment");
        case PLPGSQL_STMT_IF:
            return "IF";
        case PLPGSQL_STMT_CASE:
            return "CASE";
        case PLPGSQL_STMT_LOOP:
            return "LOOP";
        case PLPGSQL_STMT_WHILE:
            return "WHILE";
        case PLPGSQL_STMT_FORI:
            return _("FOR with integer loop variable");
        case PLPGSQL_STMT_FORS:
            return _("FOR over SELECT rows");
        case PLPGSQL_STMT_FORC:
            return _("FOR over cursor");
        case PLPGSQL_STMT_FOREACH_A:
            return _("FOREACH over array");
        case PLPGSQL_STMT_EXIT:
            return ((PLpgSQL_stmt_exit *) stmt)->is_exit ? "EXIT" : "CONTINUE";
        case PLPGSQL_STMT_RETURN:
            return "RETURN";
        case PLPGSQL_STMT_RETURN_NEXT:
            return "RETURN NEXT";
        case PLPGSQL_STMT_RETURN_QUERY:
            return "RETURN QUERY";
        case PLPGSQL_STMT_RAISE:
            return "RAISE";
        case PLPGSQL_STMT_ASSERT:
            return "ASSERT";
        case PLPGSQL_STMT_EXECSQL:
            return _("SQL statement");
        case PLPGSQL_STMT_DYNEXECUTE:
            return "EXECUTE";
        case PLPGSQL_STMT_DYNFORS:
            return _("FOR over EXECUTE statement");
        case PLPGSQL_STMT_GETDIAG:
            return ((PLpgSQL_stmt_getdiag *) stmt)->is_stacked ?
                "GET STACKED DIAGNOSTICS" : "GET DIAGNOSTICS";
        case PLPGSQL_STMT_OPEN:
            return "OPEN";
        case PLPGSQL_STMT_FETCH:
            return ((PLpgSQL_stmt_fetch *) stmt)->is_move ? "MOVE" : "FETCH";
        case PLPGSQL_STMT_CLOSE:
            return "CLOSE";
        case PLPGSQL_STMT_PERFORM:
            return "PERFORM";
        case PLPGSQL_STMT_CALL:
            return ((PLpgSQL_stmt_call *) stmt)->is_call ? "CALL" : "DO";
        case PLPGSQL_STMT_COMMIT:
            return "COMMIT";
        case PLPGSQL_STMT_ROLLBACK:
            return "ROLLBACK";
    }
 
    return "unknown";
}

References _, PLPGSQL_STMT_ASSERT, PLPGSQL_STMT_ASSIGN, PLPGSQL_STMT_BLOCK, PLPGSQL_STMT_CALL, PLPGSQL_STMT_CASE, PLPGSQL_STMT_CLOSE, PLPGSQL_STMT_COMMIT, PLPGSQL_STMT_DYNEXECUTE, PLPGSQL_STMT_DYNFORS, PLPGSQL_STMT_EXECSQL, PLPGSQL_STMT_EXIT, PLPGSQL_STMT_FETCH, PLPGSQL_STMT_FORC, PLPGSQL_STMT_FOREACH_A, PLPGSQL_STMT_FORI, PLPGSQL_STMT_FORS, PLPGSQL_STMT_GETDIAG, PLPGSQL_STMT_IF, PLPGSQL_STMT_LOOP, PLPGSQL_STMT_OPEN, PLPGSQL_STMT_PERFORM, PLPGSQL_STMT_RAISE, PLPGSQL_STMT_RETURN, PLPGSQL_STMT_RETURN_NEXT, PLPGSQL_STMT_RETURN_QUERY, PLPGSQL_STMT_ROLLBACK, PLPGSQL_STMT_WHILE, and stmt.

Referenced by plpgsql_exec_error_callback().

plpgsql_subxact_cb()

void plpgsql_subxact_cb	(	SubXactEvent	event,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid,
		void *	arg
	)

Definition at line 8766 of file pl_exec.c.

{
    if (event == SUBXACT_EVENT_COMMIT_SUB || event == SUBXACT_EVENT_ABORT_SUB)
    {
        while (simple_econtext_stack != NULL &&
               simple_econtext_stack->xact_subxid == mySubid)
        {
            SimpleEcontextStackEntry *next;
 
            FreeExprContext(simple_econtext_stack->stack_econtext,
                            (event == SUBXACT_EVENT_COMMIT_SUB));
            next = simple_econtext_stack->next;
            pfree(simple_econtext_stack);
            simple_econtext_stack = next;
        }
    }
}

References FreeExprContext(), next, SimpleEcontextStackEntry::next, pfree(), simple_econtext_stack, SimpleEcontextStackEntry::stack_econtext, SUBXACT_EVENT_ABORT_SUB, SUBXACT_EVENT_COMMIT_SUB, and SimpleEcontextStackEntry::xact_subxid.

Referenced by _PG_init(), and plpgsql_inline_handler().

plpgsql_token_is_unreserved_keyword()

bool plpgsql_token_is_unreserved_keyword

(

int

token

)

Definition at line 418 of file pl_scanner.c.

{
    int         i;
 
    for (i = 0; i < lengthof(UnreservedPLKeywordTokens); i++)
    {
        if (UnreservedPLKeywordTokens[i] == token)
            return true;
    }
    return false;
}

References i, lengthof, and UnreservedPLKeywordTokens.

plpgsql_token_length()

int plpgsql_token_length

(

yyscan_t

yyscanner

)

Definition at line 327 of file pl_scanner.c.

{
    return yyextra->plpgsql_yyleng;
}

References yyextra.

plpgsql_xact_cb()

void plpgsql_xact_cb	(	XactEvent	event,
		void *	arg
	)

Definition at line 8724 of file pl_exec.c.

{
    /*
     * If we are doing a clean transaction shutdown, free the EState and tell
     * the resowner to release whatever plancache references it has, so that
     * all remaining resources will be released correctly.  (We don't need to
     * actually delete the resowner here; deletion of the
     * TopTransactionResourceOwner will take care of that.)
     *
     * In an abort, we expect the regular abort recovery procedures to release
     * everything of interest, so just clear our pointers.
     */
    if (event == XACT_EVENT_COMMIT ||
        event == XACT_EVENT_PARALLEL_COMMIT ||
        event == XACT_EVENT_PREPARE)
    {
        simple_econtext_stack = NULL;
 
        if (shared_simple_eval_estate)
            FreeExecutorState(shared_simple_eval_estate);
        shared_simple_eval_estate = NULL;
        if (shared_simple_eval_resowner)
            ReleaseAllPlanCacheRefsInOwner(shared_simple_eval_resowner);
        shared_simple_eval_resowner = NULL;
    }
    else if (event == XACT_EVENT_ABORT ||
             event == XACT_EVENT_PARALLEL_ABORT)
    {
        simple_econtext_stack = NULL;
        shared_simple_eval_estate = NULL;
        shared_simple_eval_resowner = NULL;
    }
}

References FreeExecutorState(), ReleaseAllPlanCacheRefsInOwner(), shared_simple_eval_estate, shared_simple_eval_resowner, simple_econtext_stack, XACT_EVENT_ABORT, XACT_EVENT_COMMIT, XACT_EVENT_PARALLEL_ABORT, XACT_EVENT_PARALLEL_COMMIT, and XACT_EVENT_PREPARE.

Referenced by _PG_init().

plpgsql_yyerror()

pg_noreturn void plpgsql_yyerror	(	YYLTYPE *	yyllocp,
		PLpgSQL_stmt_block **	plpgsql_parse_result_p,
		yyscan_t	yyscanner,
		const char *	message
	)

Definition at line 534 of file pl_scanner.c.

{
    char       *yytext = yyextra->core_yy_extra.scanbuf + *yyllocp;
 
    if (*yytext == '\0')
    {
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
        /* translator: %s is typically the translation of "syntax error" */
                 errmsg("%s at end of input", _(message)),
                 plpgsql_scanner_errposition(*yyllocp, yyscanner)));
    }
    else
    {
        /*
         * If we have done any lookahead then flex will have restored the
         * character after the end-of-token.  Zap it again so that we report
         * only the single token here.  This modifies scanbuf but we no longer
         * care about that.
         */
        yytext[yyextra->plpgsql_yyleng] = '\0';
 
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
        /* translator: first %s is typically the translation of "syntax error" */
                 errmsg("%s at or near \"%s\"", _(message), yytext),
                 plpgsql_scanner_errposition(*yyllocp, yyscanner)));
    }
}

References _, ereport, errcode(), errmsg(), ERROR, plpgsql_scanner_errposition(), and yyextra.

plpgsql_yylex()

int plpgsql_yylex	(	union YYSTYPE *	yylvalp,
		YYLTYPE *	yyllocp,
		yyscan_t	yyscanner
	)

Definition at line 160 of file pl_scanner.c.

{
    int         tok1;
    TokenAuxData aux1;
    int         kwnum;
 
    tok1 = internal_yylex(&aux1, yyscanner);
    if (tok1 == IDENT || tok1 == PARAM)
    {
        int         tok2;
        TokenAuxData aux2;
 
        tok2 = internal_yylex(&aux2, yyscanner);
        if (tok2 == '.')
        {
            int         tok3;
            TokenAuxData aux3;
 
            tok3 = internal_yylex(&aux3, yyscanner);
            if (tok3 == IDENT)
            {
                int         tok4;
                TokenAuxData aux4;
 
                tok4 = internal_yylex(&aux4, yyscanner);
                if (tok4 == '.')
                {
                    int         tok5;
                    TokenAuxData aux5;
 
                    tok5 = internal_yylex(&aux5, yyscanner);
                    if (tok5 == IDENT)
                    {
                        if (plpgsql_parse_tripword(aux1.lval.str,
                                                   aux3.lval.str,
                                                   aux5.lval.str,
                                                   &aux1.lval.wdatum,
                                                   &aux1.lval.cword))
                            tok1 = T_DATUM;
                        else
                            tok1 = T_CWORD;
                        /* Adjust token length to include A.B.C */
                        aux1.leng = aux5.lloc - aux1.lloc + aux5.leng;
                    }
                    else
                    {
                        /* not A.B.C, so just process A.B */
                        push_back_token(tok5, &aux5, yyscanner);
                        push_back_token(tok4, &aux4, yyscanner);
                        if (plpgsql_parse_dblword(aux1.lval.str,
                                                  aux3.lval.str,
                                                  &aux1.lval.wdatum,
                                                  &aux1.lval.cword))
                            tok1 = T_DATUM;
                        else
                            tok1 = T_CWORD;
                        /* Adjust token length to include A.B */
                        aux1.leng = aux3.lloc - aux1.lloc + aux3.leng;
                    }
                }
                else
                {
                    /* not A.B.C, so just process A.B */
                    push_back_token(tok4, &aux4, yyscanner);
                    if (plpgsql_parse_dblword(aux1.lval.str,
                                              aux3.lval.str,
                                              &aux1.lval.wdatum,
                                              &aux1.lval.cword))
                        tok1 = T_DATUM;
                    else
                        tok1 = T_CWORD;
                    /* Adjust token length to include A.B */
                    aux1.leng = aux3.lloc - aux1.lloc + aux3.leng;
                }
            }
            else
            {
                /* not A.B, so just process A */
                push_back_token(tok3, &aux3, yyscanner);
                push_back_token(tok2, &aux2, yyscanner);
                if (plpgsql_parse_word(aux1.lval.str,
                                       yyextra->core_yy_extra.scanbuf + aux1.lloc,
                                       true,
                                       &aux1.lval.wdatum,
                                       &aux1.lval.word))
                    tok1 = T_DATUM;
                else if (!aux1.lval.word.quoted &&
                         (kwnum = ScanKeywordLookup(aux1.lval.word.ident,
                                                    &UnreservedPLKeywords)) >= 0)
                {
                    aux1.lval.keyword = GetScanKeyword(kwnum,
                                                       &UnreservedPLKeywords);
                    tok1 = UnreservedPLKeywordTokens[kwnum];
                }
                else
                    tok1 = T_WORD;
            }
        }
        else
        {
            /* not A.B, so just process A */
            push_back_token(tok2, &aux2, yyscanner);
 
            /*
             * See if it matches a variable name, except in the context where
             * we are at start of statement and the next token isn't
             * assignment or '['.  In that case, it couldn't validly be a
             * variable name, and skipping the lookup allows variable names to
             * be used that would conflict with plpgsql or core keywords that
             * introduce statements (e.g., "comment").  Without this special
             * logic, every statement-introducing keyword would effectively be
             * reserved in PL/pgSQL, which would be unpleasant.
             *
             * If it isn't a variable name, try to match against unreserved
             * plpgsql keywords.  If not one of those either, it's T_WORD.
             *
             * Note: we must call plpgsql_parse_word even if we don't want to
             * do variable lookup, because it sets up aux1.lval.word for the
             * non-variable cases.
             */
            if (plpgsql_parse_word(aux1.lval.str,
                                   yyextra->core_yy_extra.scanbuf + aux1.lloc,
                                   (!AT_STMT_START(yyextra->plpgsql_yytoken) ||
                                    (tok2 == '=' || tok2 == COLON_EQUALS ||
                                     tok2 == '[')),
                                   &aux1.lval.wdatum,
                                   &aux1.lval.word))
                tok1 = T_DATUM;
            else if (!aux1.lval.word.quoted &&
                     (kwnum = ScanKeywordLookup(aux1.lval.word.ident,
                                                &UnreservedPLKeywords)) >= 0)
            {
                aux1.lval.keyword = GetScanKeyword(kwnum,
                                                   &UnreservedPLKeywords);
                tok1 = UnreservedPLKeywordTokens[kwnum];
            }
            else
                tok1 = T_WORD;
        }
    }
    else
    {
        /*
         * Not a potential plpgsql variable name, just return the data.
         *
         * Note that we also come through here if the grammar pushed back a
         * T_DATUM, T_CWORD, T_WORD, or unreserved-keyword token returned by a
         * previous lookup cycle; thus, pushbacks do not incur extra lookup
         * work, since we'll never do the above code twice for the same token.
         * This property also makes it safe to rely on the old value of
         * plpgsql_yytoken in the is-this-start-of-statement test above.
         */
    }
 
    *yylvalp = aux1.lval;
    *yyllocp = aux1.lloc;
    yyextra->plpgsql_yyleng = aux1.leng;
    yyextra->plpgsql_yytoken = tok1;
    return tok1;
}

References AT_STMT_START, GetScanKeyword(), internal_yylex(), TokenAuxData::leng, TokenAuxData::lloc, TokenAuxData::lval, plpgsql_parse_dblword(), plpgsql_parse_tripword(), plpgsql_parse_word(), push_back_token(), ScanKeywordLookup(), UnreservedPLKeywordTokens, and yyextra.

plpgsql_yyparse()

int plpgsql_yyparse	(	PLpgSQL_stmt_block **	plpgsql_parse_result_p,
		yyscan_t	yyscanner
	)

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

Variable Documentation

plpgsql_check_asserts

bool plpgsql_check_asserts

extern

Definition at line 51 of file pl_handler.c.

Referenced by _PG_init(), and exec_stmt_assert().

plpgsql_check_syntax

bool plpgsql_check_syntax

extern

Definition at line 48 of file pl_comp.c.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_compile_tmp_cxt

MemoryContext plpgsql_compile_tmp_cxt

extern

Definition at line 53 of file pl_comp.c.

Referenced by plpgsql_compile_callback(), plpgsql_compile_inline(), plpgsql_parse_cwordrowtype(), plpgsql_parse_cwordtype(), plpgsql_parse_wordrowtype(), and plpgsql_start_datums().

plpgsql_curr_compile

PLpgSQL_function* plpgsql_curr_compile

extern

Definition at line 50 of file pl_comp.c.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_Datums

PLpgSQL_datum** plpgsql_Datums

extern

Definition at line 43 of file pl_comp.c.

Referenced by plpgsql_add_initdatums(), plpgsql_adddatum(), plpgsql_build_recfield(), plpgsql_finish_datums(), plpgsql_parse_cwordtype(), plpgsql_parse_dblword(), plpgsql_parse_tripword(), plpgsql_parse_word(), plpgsql_parse_wordtype(), and plpgsql_start_datums().

plpgsql_DumpExecTree

bool plpgsql_DumpExecTree

extern

Definition at line 47 of file pl_comp.c.

Referenced by plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_error_funcname

char* plpgsql_error_funcname

extern

Definition at line 46 of file pl_comp.c.

Referenced by plpgsql_compile_callback(), plpgsql_compile_error_callback(), and plpgsql_compile_inline().

plpgsql_extra_errors

int plpgsql_extra_errors

extern

Definition at line 56 of file pl_handler.c.

Referenced by exec_move_row_from_fields(), exec_stmt_execsql(), plpgsql_compile_callback(), and plpgsql_extra_errors_assign_hook().

plpgsql_extra_warnings

int plpgsql_extra_warnings

extern

Definition at line 55 of file pl_handler.c.

Referenced by exec_move_row_from_fields(), exec_stmt_execsql(), plpgsql_compile_callback(), and plpgsql_extra_warnings_assign_hook().

plpgsql_IdentifierLookup

IdentifierLookup plpgsql_IdentifierLookup

extern

Definition at line 26 of file pl_scanner.c.

Referenced by plpgsql_parse_dblword(), plpgsql_parse_tripword(), plpgsql_parse_word(), and plpgsql_scanner_init().

plpgsql_nDatums

int plpgsql_nDatums

extern

Definition at line 42 of file pl_comp.c.

Referenced by plpgsql_add_initdatums(), plpgsql_adddatum(), plpgsql_finish_datums(), and plpgsql_start_datums().

plpgsql_plugin_ptr

PLpgSQL_plugin** plpgsql_plugin_ptr

extern

Definition at line 59 of file pl_handler.c.

Referenced by _PG_init(), exec_stmts(), exec_toplevel_block(), plpgsql_estate_setup(), plpgsql_exec_event_trigger(), plpgsql_exec_function(), and plpgsql_exec_trigger().

plpgsql_print_strict_params

bool plpgsql_print_strict_params

extern

Definition at line 49 of file pl_handler.c.

Referenced by _PG_init(), plpgsql_compile_callback(), and plpgsql_compile_inline().

plpgsql_variable_conflict

int plpgsql_variable_conflict

extern

Definition at line 47 of file pl_handler.c.

Referenced by _PG_init(), plpgsql_compile_callback(), and plpgsql_compile_inline().