pl_comp.c File Reference

#include "postgres.h"
#include <ctype.h>
#include "access/htup_details.h"
#include "catalog/namespace.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "nodes/makefuncs.h"
#include "parser/parse_node.h"
#include "plpgsql.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/regproc.h"
#include "utils/syscache.h"
#include "utils/typcache.h"
#include "plerrcodes.h"

Include dependency graph for pl_comp.c:

Go to the source code of this file.

Data Structures
struct	plpgsql_hashent
struct	ExceptionLabelMap
struct	compile_error_callback_arg

Macros
#define	FUNCS_PER_USER   128 /* initial table size */

Typedefs
typedef struct plpgsql_hashent	plpgsql_HashEnt

Functions
static PLpgSQL_function *	do_compile (FunctionCallInfo fcinfo, HeapTuple procTup, PLpgSQL_function *function, PLpgSQL_func_hashkey *hashkey, bool forValidator)
static void	plpgsql_compile_error_callback (void *arg)
static void	add_parameter_name (PLpgSQL_nsitem_type itemtype, int itemno, const char *name)
static void	add_dummy_return (PLpgSQL_function *function)
static Node *	plpgsql_pre_column_ref (ParseState *pstate, ColumnRef *cref)
static Node *	plpgsql_post_column_ref (ParseState *pstate, ColumnRef *cref, Node *var)
static Node *	plpgsql_param_ref (ParseState *pstate, ParamRef *pref)
static Node *	resolve_column_ref (ParseState *pstate, PLpgSQL_expr *expr, ColumnRef *cref, bool error_if_no_field)
static Node *	make_datum_param (PLpgSQL_expr *expr, int dno, int location)
static PLpgSQL_row *	build_row_from_vars (PLpgSQL_variable **vars, int numvars)
static PLpgSQL_type *	build_datatype (HeapTuple typeTup, int32 typmod, Oid collation, TypeName *origtypname)
static void	plpgsql_start_datums (void)
static void	plpgsql_finish_datums (PLpgSQL_function *function)
static void	compute_function_hashkey (FunctionCallInfo fcinfo, Form_pg_proc procStruct, PLpgSQL_func_hashkey *hashkey, bool forValidator)
static void	plpgsql_resolve_polymorphic_argtypes (int numargs, Oid *argtypes, char *argmodes, Node *call_expr, bool forValidator, const char *proname)
static PLpgSQL_function *	plpgsql_HashTableLookup (PLpgSQL_func_hashkey *func_key)
static void	plpgsql_HashTableInsert (PLpgSQL_function *function, PLpgSQL_func_hashkey *func_key)
static void	plpgsql_HashTableDelete (PLpgSQL_function *function)
static void	delete_function (PLpgSQL_function *func)
PLpgSQL_function *	plpgsql_compile (FunctionCallInfo fcinfo, bool forValidator)
PLpgSQL_function *	plpgsql_compile_inline (char *proc_source)
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)
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)
PLpgSQL_type *	plpgsql_build_datatype (Oid typeOid, int32 typmod, Oid collation, TypeName *origtypname)
PLpgSQL_type *	plpgsql_build_datatype_arrayof (PLpgSQL_type *dtype)
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)
void	plpgsql_HashTableInit (void)

Variables
PLpgSQL_stmt_block *	plpgsql_parse_result
static int	datums_alloc
int	plpgsql_nDatums
PLpgSQL_datum **	plpgsql_Datums
static int	datums_last
char *	plpgsql_error_funcname
bool	plpgsql_DumpExecTree = false
bool	plpgsql_check_syntax = false
PLpgSQL_function *	plpgsql_curr_compile
MemoryContext	plpgsql_compile_tmp_cxt
static HTAB *	plpgsql_HashTable = NULL
static const ExceptionLabelMap	exception_label_map []

Macro Definition Documentation

FUNCS_PER_USER

#define FUNCS_PER_USER   128 /* initial table size */

Definition at line 69 of file pl_comp.c.

Typedef Documentation

plpgsql_HashEnt

typedef struct plpgsql_hashent plpgsql_HashEnt

Function Documentation

add_dummy_return()

static void add_dummy_return ( PLpgSQL_function *  function )

static

Definition at line 1044 of file pl_comp.c.

{
    /*
     * If the outer block has an EXCEPTION clause, we need to make a new outer
     * block, since the added RETURN shouldn't act like it is inside the
     * EXCEPTION clause.  Likewise, if it has a label, wrap it in a new outer
     * block so that EXIT doesn't skip the RETURN.
     */
    if (function->action->exceptions != NULL ||
        function->action->label != NULL)
    {
        PLpgSQL_stmt_block *new;
 
        new = palloc0(sizeof(PLpgSQL_stmt_block));
        new->cmd_type = PLPGSQL_STMT_BLOCK;
        new->stmtid = ++function->nstatements;
        new->body = list_make1(function->action);
 
        function->action = new;
    }
    if (function->action->body == NIL ||
        ((PLpgSQL_stmt *) llast(function->action->body))->cmd_type != PLPGSQL_STMT_RETURN)
    {
        PLpgSQL_stmt_return *new;
 
        new = palloc0(sizeof(PLpgSQL_stmt_return));
        new->cmd_type = PLPGSQL_STMT_RETURN;
        new->stmtid = ++function->nstatements;
        new->expr = NULL;
        new->retvarno = function->out_param_varno;
 
        function->action->body = lappend(function->action->body, new);
    }
}

References function, lappend(), list_make1, llast, NIL, palloc0(), PLPGSQL_STMT_BLOCK, and PLPGSQL_STMT_RETURN.

Referenced by do_compile(), and plpgsql_compile_inline().

add_parameter_name()

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

static

Definition at line 1019 of file pl_comp.c.

{
    /*
     * Before adding the name, check for duplicates.  We need this even though
     * functioncmds.c has a similar check, because that code explicitly
     * doesn't complain about conflicting IN and OUT parameter names.  In
     * plpgsql, such names are in the same namespace, so there is no way to
     * disambiguate.
     */
    if (plpgsql_ns_lookup(plpgsql_ns_top(), true,
                          name, NULL, NULL,
                          NULL) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("parameter name \"%s\" used more than once",
                        name)));
 
    /* OK, add the name */
    plpgsql_ns_additem(itemtype, itemno, name);
}

References ereport, errcode(), errmsg(), ERROR, name, plpgsql_ns_additem(), plpgsql_ns_lookup(), and plpgsql_ns_top().

Referenced by do_compile().

build_datatype()

static PLpgSQL_type * build_datatype ( HeapTuple  typeTup, int32  typmod, Oid  collation, TypeName *  origtypname  )

static

Definition at line 2078 of file pl_comp.c.

{
    Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
    PLpgSQL_type *typ;
 
    if (!typeStruct->typisdefined)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type \"%s\" is only a shell",
                        NameStr(typeStruct->typname))));
 
    typ = (PLpgSQL_type *) palloc(sizeof(PLpgSQL_type));
 
    typ->typname = pstrdup(NameStr(typeStruct->typname));
    typ->typoid = typeStruct->oid;
    switch (typeStruct->typtype)
    {
        case TYPTYPE_BASE:
        case TYPTYPE_ENUM:
        case TYPTYPE_RANGE:
        case TYPTYPE_MULTIRANGE:
            typ->ttype = PLPGSQL_TTYPE_SCALAR;
            break;
        case TYPTYPE_COMPOSITE:
            typ->ttype = PLPGSQL_TTYPE_REC;
            break;
        case TYPTYPE_DOMAIN:
            if (type_is_rowtype(typeStruct->typbasetype))
                typ->ttype = PLPGSQL_TTYPE_REC;
            else
                typ->ttype = PLPGSQL_TTYPE_SCALAR;
            break;
        case TYPTYPE_PSEUDO:
            if (typ->typoid == RECORDOID)
                typ->ttype = PLPGSQL_TTYPE_REC;
            else
                typ->ttype = PLPGSQL_TTYPE_PSEUDO;
            break;
        default:
            elog(ERROR, "unrecognized typtype: %d",
                 (int) typeStruct->typtype);
            break;
    }
    typ->typlen = typeStruct->typlen;
    typ->typbyval = typeStruct->typbyval;
    typ->typtype = typeStruct->typtype;
    typ->collation = typeStruct->typcollation;
    if (OidIsValid(collation) && OidIsValid(typ->collation))
        typ->collation = collation;
    /* Detect if type is true array, or domain thereof */
    /* NB: this is only used to decide whether to apply expand_array */
    if (typeStruct->typtype == TYPTYPE_BASE)
    {
        /*
         * This test should include what get_element_type() checks.  We also
         * disallow non-toastable array types (i.e. oidvector and int2vector).
         */
        typ->typisarray = (IsTrueArrayType(typeStruct) &&
                           typeStruct->typstorage != TYPSTORAGE_PLAIN);
    }
    else if (typeStruct->typtype == TYPTYPE_DOMAIN)
    {
        /* we can short-circuit looking up base types if it's not varlena */
        typ->typisarray = (typeStruct->typlen == -1 &&
                           typeStruct->typstorage != TYPSTORAGE_PLAIN &&
                           OidIsValid(get_base_element_type(typeStruct->typbasetype)));
    }
    else
        typ->typisarray = false;
    typ->atttypmod = typmod;
 
    /*
     * If it's a named composite type (or domain over one), find the typcache
     * entry and record the current tupdesc ID, so we can detect changes
     * (including drops).  We don't currently support on-the-fly replacement
     * of non-composite types, else we might want to do this for them too.
     */
    if (typ->ttype == PLPGSQL_TTYPE_REC && typ->typoid != RECORDOID)
    {
        TypeCacheEntry *typentry;
 
        typentry = lookup_type_cache(typ->typoid,
                                     TYPECACHE_TUPDESC |
                                     TYPECACHE_DOMAIN_BASE_INFO);
        if (typentry->typtype == TYPTYPE_DOMAIN)
            typentry = lookup_type_cache(typentry->domainBaseType,
                                         TYPECACHE_TUPDESC);
        if (typentry->tupDesc == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is not composite",
                            format_type_be(typ->typoid))));
 
        typ->origtypname = origtypname;
        typ->tcache = typentry;
        typ->tupdesc_id = typentry->tupDesc_identifier;
    }
    else
    {
        typ->origtypname = NULL;
        typ->tcache = NULL;
        typ->tupdesc_id = 0;
    }
 
    return typ;
}

References PLpgSQL_type::atttypmod, PLpgSQL_type::collation, TypeCacheEntry::domainBaseType, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_base_element_type(), GETSTRUCT, lookup_type_cache(), NameStr, OidIsValid, PLpgSQL_type::origtypname, palloc(), PLPGSQL_TTYPE_PSEUDO, PLPGSQL_TTYPE_REC, PLPGSQL_TTYPE_SCALAR, pstrdup(), PLpgSQL_type::tcache, PLpgSQL_type::ttype, TypeCacheEntry::tupDesc, PLpgSQL_type::tupdesc_id, TypeCacheEntry::tupDesc_identifier, PLpgSQL_type::typbyval, type_is_rowtype(), TYPECACHE_DOMAIN_BASE_INFO, TYPECACHE_TUPDESC, PLpgSQL_type::typisarray, PLpgSQL_type::typlen, PLpgSQL_type::typname, PLpgSQL_type::typoid, TypeCacheEntry::typtype, and PLpgSQL_type::typtype.

Referenced by do_compile(), plpgsql_build_datatype(), and plpgsql_parse_cwordtype().

build_row_from_vars()

static PLpgSQL_row * build_row_from_vars ( PLpgSQL_variable **  vars, int  numvars  )

static

Definition at line 1942 of file pl_comp.c.

{
    PLpgSQL_row *row;
    int         i;
 
    row = palloc0(sizeof(PLpgSQL_row));
    row->dtype = PLPGSQL_DTYPE_ROW;
    row->refname = "(unnamed row)";
    row->lineno = -1;
    row->rowtupdesc = CreateTemplateTupleDesc(numvars);
    row->nfields = numvars;
    row->fieldnames = palloc(numvars * sizeof(char *));
    row->varnos = palloc(numvars * sizeof(int));
 
    for (i = 0; i < numvars; i++)
    {
        PLpgSQL_variable *var = vars[i];
        Oid         typoid;
        int32       typmod;
        Oid         typcoll;
 
        /* Member vars of a row should never be const */
        Assert(!var->isconst);
 
        switch (var->dtype)
        {
            case PLPGSQL_DTYPE_VAR:
            case PLPGSQL_DTYPE_PROMISE:
                typoid = ((PLpgSQL_var *) var)->datatype->typoid;
                typmod = ((PLpgSQL_var *) var)->datatype->atttypmod;
                typcoll = ((PLpgSQL_var *) var)->datatype->collation;
                break;
 
            case PLPGSQL_DTYPE_REC:
                /* shouldn't need to revalidate rectypeid already... */
                typoid = ((PLpgSQL_rec *) var)->rectypeid;
                typmod = -1;    /* don't know typmod, if it's used at all */
                typcoll = InvalidOid;   /* composite types have no collation */
                break;
 
            default:
                elog(ERROR, "unrecognized dtype: %d", var->dtype);
                typoid = InvalidOid;    /* keep compiler quiet */
                typmod = 0;
                typcoll = InvalidOid;
                break;
        }
 
        row->fieldnames[i] = var->refname;
        row->varnos[i] = var->dno;
 
        TupleDescInitEntry(row->rowtupdesc, i + 1,
                           var->refname,
                           typoid, typmod,
                           0);
        TupleDescInitEntryCollation(row->rowtupdesc, i + 1, typcoll);
    }
 
    return row;
}

References Assert, CreateTemplateTupleDesc(), PLpgSQL_variable::dno, PLpgSQL_variable::dtype, PLpgSQL_row::dtype, elog, ERROR, PLpgSQL_row::fieldnames, i, InvalidOid, PLpgSQL_variable::isconst, PLpgSQL_row::lineno, PLpgSQL_row::nfields, palloc(), palloc0(), PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_ROW, PLPGSQL_DTYPE_VAR, PLpgSQL_variable::refname, PLpgSQL_row::refname, PLpgSQL_row::rowtupdesc, TupleDescInitEntry(), TupleDescInitEntryCollation(), and PLpgSQL_row::varnos.

Referenced by do_compile().

compute_function_hashkey()

static void compute_function_hashkey ( FunctionCallInfo  fcinfo, Form_pg_proc  procStruct, PLpgSQL_func_hashkey *  hashkey, bool  forValidator  )

static

Definition at line 2444 of file pl_comp.c.

{
    /* Make sure any unused bytes of the struct are zero */
    MemSet(hashkey, 0, sizeof(PLpgSQL_func_hashkey));
 
    /* get function OID */
    hashkey->funcOid = fcinfo->flinfo->fn_oid;
 
    /* get call context */
    hashkey->isTrigger = CALLED_AS_TRIGGER(fcinfo);
    hashkey->isEventTrigger = CALLED_AS_EVENT_TRIGGER(fcinfo);
 
    /*
     * If DML trigger, include trigger's OID in the hash, so that each trigger
     * usage gets a different hash entry, allowing for e.g. different relation
     * rowtypes or transition table names.  In validation mode we do not know
     * what relation or transition table names are intended to be used, so we
     * leave trigOid zero; the hash entry built in this case will never be
     * used for any actual calls.
     *
     * We don't currently need to distinguish different event trigger usages
     * in the same way, since the special parameter variables don't vary in
     * type in that case.
     */
    if (hashkey->isTrigger && !forValidator)
    {
        TriggerData *trigdata = (TriggerData *) fcinfo->context;
 
        hashkey->trigOid = trigdata->tg_trigger->tgoid;
    }
 
    /* get input collation, if known */
    hashkey->inputCollation = fcinfo->fncollation;
 
    if (procStruct->pronargs > 0)
    {
        /* get the argument types */
        memcpy(hashkey->argtypes, procStruct->proargtypes.values,
               procStruct->pronargs * sizeof(Oid));
 
        /* resolve any polymorphic argument types */
        plpgsql_resolve_polymorphic_argtypes(procStruct->pronargs,
                                             hashkey->argtypes,
                                             NULL,
                                             fcinfo->flinfo->fn_expr,
                                             forValidator,
                                             NameStr(procStruct->proname));
    }
}

References PLpgSQL_func_hashkey::argtypes, CALLED_AS_EVENT_TRIGGER, CALLED_AS_TRIGGER, FunctionCallInfoBaseData::context, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_expr, FmgrInfo::fn_oid, FunctionCallInfoBaseData::fncollation, PLpgSQL_func_hashkey::funcOid, PLpgSQL_func_hashkey::inputCollation, PLpgSQL_func_hashkey::isEventTrigger, PLpgSQL_func_hashkey::isTrigger, MemSet, NameStr, plpgsql_resolve_polymorphic_argtypes(), TriggerData::tg_trigger, Trigger::tgoid, and PLpgSQL_func_hashkey::trigOid.

Referenced by plpgsql_compile().

delete_function()

static void delete_function ( PLpgSQL_function *  func )

static

Definition at line 2595 of file pl_comp.c.

{
    /* remove function from hash table (might be done already) */
    plpgsql_HashTableDelete(func);
 
    /* release the function's storage if safe and not done already */
    if (func->use_count == 0)
        plpgsql_free_function_memory(func);
}

References plpgsql_free_function_memory(), plpgsql_HashTableDelete(), and PLpgSQL_function::use_count.

Referenced by plpgsql_compile().

do_compile()

static PLpgSQL_function * do_compile ( FunctionCallInfo  fcinfo, HeapTuple  procTup, PLpgSQL_function *  function, PLpgSQL_func_hashkey *  hashkey, bool  forValidator  )

static

Definition at line 269 of file pl_comp.c.

{
    Form_pg_proc procStruct = (Form_pg_proc) GETSTRUCT(procTup);
    bool        is_dml_trigger = CALLED_AS_TRIGGER(fcinfo);
    bool        is_event_trigger = CALLED_AS_EVENT_TRIGGER(fcinfo);
    yyscan_t    scanner;
    Datum       prosrcdatum;
    char       *proc_source;
    HeapTuple   typeTup;
    Form_pg_type typeStruct;
    PLpgSQL_variable *var;
    PLpgSQL_rec *rec;
    int         i;
    struct compile_error_callback_arg cbarg;
    ErrorContextCallback plerrcontext;
    int         parse_rc;
    Oid         rettypeid;
    int         numargs;
    int         num_in_args = 0;
    int         num_out_args = 0;
    Oid        *argtypes;
    char      **argnames;
    char       *argmodes;
    int        *in_arg_varnos = NULL;
    PLpgSQL_variable **out_arg_variables;
    MemoryContext func_cxt;
 
    /*
     * Setup the scanner input and error info.
     */
    prosrcdatum = SysCacheGetAttrNotNull(PROCOID, procTup, Anum_pg_proc_prosrc);
    proc_source = TextDatumGetCString(prosrcdatum);
    scanner = plpgsql_scanner_init(proc_source);
 
    plpgsql_error_funcname = pstrdup(NameStr(procStruct->proname));
 
    /*
     * Setup error traceback support for ereport()
     */
    cbarg.proc_source = forValidator ? proc_source : NULL;
    cbarg.yyscanner = scanner;
    plerrcontext.callback = plpgsql_compile_error_callback;
    plerrcontext.arg = &cbarg;
    plerrcontext.previous = error_context_stack;
    error_context_stack = &plerrcontext;
 
    /*
     * Do extra syntax checks when validating the function definition. We skip
     * this when actually compiling functions for execution, for performance
     * reasons.
     */
    plpgsql_check_syntax = forValidator;
 
    /*
     * Create the new function struct, if not done already.  The function
     * structs are never thrown away, so keep them in TopMemoryContext.
     */
    if (function == NULL)
    {
        function = (PLpgSQL_function *)
            MemoryContextAllocZero(TopMemoryContext, sizeof(PLpgSQL_function));
    }
    else
    {
        /* re-using a previously existing struct, so clear it out */
        memset(function, 0, sizeof(PLpgSQL_function));
    }
    plpgsql_curr_compile = function;
 
    /*
     * All the permanent output of compilation (e.g. parse tree) is kept in a
     * per-function memory context, so it can be reclaimed easily.
     */
    func_cxt = AllocSetContextCreate(TopMemoryContext,
                                     "PL/pgSQL function",
                                     ALLOCSET_DEFAULT_SIZES);
    plpgsql_compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);
 
    function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
    MemoryContextSetIdentifier(func_cxt, function->fn_signature);
    function->fn_oid = fcinfo->flinfo->fn_oid;
    function->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
    function->fn_tid = procTup->t_self;
    function->fn_input_collation = fcinfo->fncollation;
    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;
    /* only promote extra warnings and errors at CREATE FUNCTION time */
    function->extra_warnings = forValidator ? plpgsql_extra_warnings : 0;
    function->extra_errors = forValidator ? plpgsql_extra_errors : 0;
 
    if (is_dml_trigger)
        function->fn_is_trigger = PLPGSQL_DML_TRIGGER;
    else if (is_event_trigger)
        function->fn_is_trigger = PLPGSQL_EVENT_TRIGGER;
    else
        function->fn_is_trigger = PLPGSQL_NOT_TRIGGER;
 
    function->fn_prokind = procStruct->prokind;
 
    function->nstatements = 0;
    function->requires_procedure_resowner = false;
 
    /*
     * Initialize the compiler, particularly the namespace stack.  The
     * outermost namespace contains function parameters and other special
     * variables (such as FOUND), and is named after the function itself.
     */
    plpgsql_ns_init();
    plpgsql_ns_push(NameStr(procStruct->proname), PLPGSQL_LABEL_BLOCK);
    plpgsql_DumpExecTree = false;
    plpgsql_start_datums();
 
    switch (function->fn_is_trigger)
    {
        case PLPGSQL_NOT_TRIGGER:
 
            /*
             * Fetch info about the procedure's parameters. Allocations aren't
             * needed permanently, so make them in tmp cxt.
             *
             * We also need to resolve any polymorphic input or output
             * argument types.  In validation mode we won't be able to, so we
             * arbitrarily assume we are dealing with integers.
             */
            MemoryContextSwitchTo(plpgsql_compile_tmp_cxt);
 
            numargs = get_func_arg_info(procTup,
                                        &argtypes, &argnames, &argmodes);
 
            plpgsql_resolve_polymorphic_argtypes(numargs, argtypes, argmodes,
                                                 fcinfo->flinfo->fn_expr,
                                                 forValidator,
                                                 plpgsql_error_funcname);
 
            in_arg_varnos = (int *) palloc(numargs * sizeof(int));
            out_arg_variables = (PLpgSQL_variable **) palloc(numargs * sizeof(PLpgSQL_variable *));
 
            MemoryContextSwitchTo(func_cxt);
 
            /*
             * Create the variables for the procedure's parameters.
             */
            for (i = 0; i < numargs; i++)
            {
                char        buf[32];
                Oid         argtypeid = argtypes[i];
                char        argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
                PLpgSQL_type *argdtype;
                PLpgSQL_variable *argvariable;
                PLpgSQL_nsitem_type argitemtype;
 
                /* Create $n name for variable */
                snprintf(buf, sizeof(buf), "$%d", i + 1);
 
                /* Create datatype info */
                argdtype = plpgsql_build_datatype(argtypeid,
                                                  -1,
                                                  function->fn_input_collation,
                                                  NULL);
 
                /* Disallow pseudotype argument */
                /* (note we already replaced polymorphic types) */
                /* (build_variable would do this, but wrong message) */
                if (argdtype->ttype == PLPGSQL_TTYPE_PSEUDO)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("PL/pgSQL functions cannot accept type %s",
                                    format_type_be(argtypeid))));
 
                /*
                 * Build variable and add to datum list.  If there's a name
                 * for the argument, use that as refname, else use $n name.
                 */
                argvariable = plpgsql_build_variable((argnames &&
                                                      argnames[i][0] != '\0') ?
                                                     argnames[i] : buf,
                                                     0, argdtype, false);
 
                if (argvariable->dtype == PLPGSQL_DTYPE_VAR)
                {
                    argitemtype = PLPGSQL_NSTYPE_VAR;
                }
                else
                {
                    Assert(argvariable->dtype == PLPGSQL_DTYPE_REC);
                    argitemtype = PLPGSQL_NSTYPE_REC;
                }
 
                /* Remember arguments in appropriate arrays */
                if (argmode == PROARGMODE_IN ||
                    argmode == PROARGMODE_INOUT ||
                    argmode == PROARGMODE_VARIADIC)
                    in_arg_varnos[num_in_args++] = argvariable->dno;
                if (argmode == PROARGMODE_OUT ||
                    argmode == PROARGMODE_INOUT ||
                    argmode == PROARGMODE_TABLE)
                    out_arg_variables[num_out_args++] = argvariable;
 
                /* Add to namespace under the $n name */
                add_parameter_name(argitemtype, argvariable->dno, buf);
 
                /* If there's a name for the argument, make an alias */
                if (argnames && argnames[i][0] != '\0')
                    add_parameter_name(argitemtype, argvariable->dno,
                                       argnames[i]);
            }
 
            /*
             * If there's just one OUT parameter, out_param_varno points
             * directly to it.  If there's more than one, build a row that
             * holds all of them.  Procedures return a row even for one OUT
             * parameter.
             */
            if (num_out_args > 1 ||
                (num_out_args == 1 && function->fn_prokind == PROKIND_PROCEDURE))
            {
                PLpgSQL_row *row = build_row_from_vars(out_arg_variables,
                                                       num_out_args);
 
                plpgsql_adddatum((PLpgSQL_datum *) row);
                function->out_param_varno = row->dno;
            }
            else if (num_out_args == 1)
                function->out_param_varno = out_arg_variables[0]->dno;
 
            /*
             * Check for a polymorphic returntype. If found, use the actual
             * returntype type from the caller's FuncExpr node, if we have
             * one.  (In validation mode we arbitrarily assume we are dealing
             * with integers.)
             *
             * Note: errcode is FEATURE_NOT_SUPPORTED because it should always
             * work; if it doesn't we're in some context that fails to make
             * the info available.
             */
            rettypeid = procStruct->prorettype;
            if (IsPolymorphicType(rettypeid))
            {
                if (forValidator)
                {
                    if (rettypeid == ANYARRAYOID ||
                        rettypeid == ANYCOMPATIBLEARRAYOID)
                        rettypeid = INT4ARRAYOID;
                    else if (rettypeid == ANYRANGEOID ||
                             rettypeid == ANYCOMPATIBLERANGEOID)
                        rettypeid = INT4RANGEOID;
                    else if (rettypeid == ANYMULTIRANGEOID)
                        rettypeid = INT4MULTIRANGEOID;
                    else        /* ANYELEMENT or ANYNONARRAY or ANYCOMPATIBLE */
                        rettypeid = INT4OID;
                    /* XXX what could we use for ANYENUM? */
                }
                else
                {
                    rettypeid = get_fn_expr_rettype(fcinfo->flinfo);
                    if (!OidIsValid(rettypeid))
                        ereport(ERROR,
                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                 errmsg("could not determine actual return type "
                                        "for polymorphic function \"%s\"",
                                        plpgsql_error_funcname)));
                }
            }
 
            /*
             * Normal function has a defined returntype
             */
            function->fn_rettype = rettypeid;
            function->fn_retset = procStruct->proretset;
 
            /*
             * Lookup the function's return type
             */
            typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(rettypeid));
            if (!HeapTupleIsValid(typeTup))
                elog(ERROR, "cache lookup failed for type %u", rettypeid);
            typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
 
            /* Disallow pseudotype result, except VOID or RECORD */
            /* (note we already replaced polymorphic types) */
            if (typeStruct->typtype == TYPTYPE_PSEUDO)
            {
                if (rettypeid == VOIDOID ||
                    rettypeid == RECORDOID)
                     /* okay */ ;
                else if (rettypeid == TRIGGEROID || rettypeid == EVENT_TRIGGEROID)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("trigger functions can only be called as triggers")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("PL/pgSQL functions cannot return type %s",
                                    format_type_be(rettypeid))));
            }
 
            function->fn_retistuple = type_is_rowtype(rettypeid);
            function->fn_retisdomain = (typeStruct->typtype == TYPTYPE_DOMAIN);
            function->fn_retbyval = typeStruct->typbyval;
            function->fn_rettyplen = typeStruct->typlen;
 
            /*
             * install $0 reference, but only for polymorphic return types,
             * and not when the return is specified through an output
             * parameter.
             */
            if (IsPolymorphicType(procStruct->prorettype) &&
                num_out_args == 0)
            {
                (void) plpgsql_build_variable("$0", 0,
                                              build_datatype(typeTup,
                                                             -1,
                                                             function->fn_input_collation,
                                                             NULL),
                                              true);
            }
 
            ReleaseSysCache(typeTup);
            break;
 
        case PLPGSQL_DML_TRIGGER:
            /* Trigger procedure's return type is unknown yet */
            function->fn_rettype = InvalidOid;
            function->fn_retbyval = false;
            function->fn_retistuple = true;
            function->fn_retisdomain = false;
            function->fn_retset = false;
 
            /* shouldn't be any declared arguments */
            if (procStruct->pronargs != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("trigger functions cannot have declared arguments"),
                         errhint("The arguments of the trigger can be accessed through TG_NARGS and TG_ARGV instead.")));
 
            /* Add the record for referencing NEW ROW */
            rec = plpgsql_build_record("new", 0, NULL, RECORDOID, true);
            function->new_varno = rec->dno;
 
            /* Add the record for referencing OLD ROW */
            rec = plpgsql_build_record("old", 0, NULL, RECORDOID, true);
            function->old_varno = rec->dno;
 
            /* Add the variable tg_name */
            var = plpgsql_build_variable("tg_name", 0,
                                         plpgsql_build_datatype(NAMEOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_NAME;
 
            /* Add the variable tg_when */
            var = plpgsql_build_variable("tg_when", 0,
                                         plpgsql_build_datatype(TEXTOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_WHEN;
 
            /* Add the variable tg_level */
            var = plpgsql_build_variable("tg_level", 0,
                                         plpgsql_build_datatype(TEXTOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_LEVEL;
 
            /* Add the variable tg_op */
            var = plpgsql_build_variable("tg_op", 0,
                                         plpgsql_build_datatype(TEXTOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_OP;
 
            /* Add the variable tg_relid */
            var = plpgsql_build_variable("tg_relid", 0,
                                         plpgsql_build_datatype(OIDOID,
                                                                -1,
                                                                InvalidOid,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_RELID;
 
            /* Add the variable tg_relname */
            var = plpgsql_build_variable("tg_relname", 0,
                                         plpgsql_build_datatype(NAMEOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_NAME;
 
            /* tg_table_name is now preferred to tg_relname */
            var = plpgsql_build_variable("tg_table_name", 0,
                                         plpgsql_build_datatype(NAMEOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_NAME;
 
            /* add the variable tg_table_schema */
            var = plpgsql_build_variable("tg_table_schema", 0,
                                         plpgsql_build_datatype(NAMEOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TABLE_SCHEMA;
 
            /* Add the variable tg_nargs */
            var = plpgsql_build_variable("tg_nargs", 0,
                                         plpgsql_build_datatype(INT4OID,
                                                                -1,
                                                                InvalidOid,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_NARGS;
 
            /* Add the variable tg_argv */
            var = plpgsql_build_variable("tg_argv", 0,
                                         plpgsql_build_datatype(TEXTARRAYOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_ARGV;
 
            break;
 
        case PLPGSQL_EVENT_TRIGGER:
            function->fn_rettype = VOIDOID;
            function->fn_retbyval = false;
            function->fn_retistuple = true;
            function->fn_retisdomain = false;
            function->fn_retset = false;
 
            /* shouldn't be any declared arguments */
            if (procStruct->pronargs != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("event trigger functions cannot have declared arguments")));
 
            /* Add the variable tg_event */
            var = plpgsql_build_variable("tg_event", 0,
                                         plpgsql_build_datatype(TEXTOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_EVENT;
 
            /* Add the variable tg_tag */
            var = plpgsql_build_variable("tg_tag", 0,
                                         plpgsql_build_datatype(TEXTOID,
                                                                -1,
                                                                function->fn_input_collation,
                                                                NULL),
                                         true);
            Assert(var->dtype == PLPGSQL_DTYPE_VAR);
            var->dtype = PLPGSQL_DTYPE_PROMISE;
            ((PLpgSQL_var *) var)->promise = PLPGSQL_PROMISE_TG_TAG;
 
            break;
 
        default:
            elog(ERROR, "unrecognized function typecode: %d",
                 (int) function->fn_is_trigger);
            break;
    }
 
    /* Remember if function is STABLE/IMMUTABLE */
    function->fn_readonly = (procStruct->provolatile != PROVOLATILE_VOLATILE);
 
    /*
     * 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(scanner);
    if (parse_rc != 0)
        elog(ERROR, "plpgsql parser returned %d", parse_rc);
    function->action = plpgsql_parse_result;
 
    plpgsql_scanner_finish(scanner);
    pfree(proc_source);
 
    /*
     * If it has OUT parameters or returns VOID or returns a set, we allow
     * control to fall off the end without an explicit RETURN statement. The
     * easiest way to implement this is to add a RETURN statement to the end
     * of the statement list during parsing.
     */
    if (num_out_args > 0 || function->fn_rettype == VOIDOID ||
        function->fn_retset)
        add_dummy_return(function);
 
    /*
     * Complete the function's info
     */
    function->fn_nargs = procStruct->pronargs;
    for (i = 0; i < function->fn_nargs; i++)
        function->fn_argvarnos[i] = in_arg_varnos[i];
 
    plpgsql_finish_datums(function);
 
    /* Debug dump for completed functions */
    if (plpgsql_DumpExecTree)
        plpgsql_dumptree(function);
 
    /*
     * add it to the hash table
     */
    plpgsql_HashTableInsert(function, hashkey);
 
    /*
     * 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(), add_parameter_name(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, buf, build_datatype(), build_row_from_vars(), CALLED_AS_EVENT_TRIGGER, CALLED_AS_TRIGGER, PLpgSQL_variable::dno, PLpgSQL_row::dno, PLpgSQL_rec::dno, PLpgSQL_variable::dtype, elog, ereport, errcode(), errhint(), errmsg(), ERROR, error_context_stack, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_expr, FmgrInfo::fn_oid, FunctionCallInfoBaseData::fncollation, format_procedure(), format_type_be(), function, get_fn_expr_rettype(), get_func_arg_info(), GETSTRUCT, HeapTupleHeaderGetRawXmin, HeapTupleIsValid, i, InvalidOid, MemoryContextAllocZero(), MemoryContextSetIdentifier(), MemoryContextSwitchTo(), NameStr, ObjectIdGetDatum(), OidIsValid, palloc(), pfree(), plpgsql_adddatum(), plpgsql_build_datatype(), plpgsql_build_record(), plpgsql_build_variable(), plpgsql_check_syntax, plpgsql_compile_error_callback(), plpgsql_compile_tmp_cxt, plpgsql_curr_compile, PLPGSQL_DML_TRIGGER, PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_VAR, plpgsql_DumpExecTree, plpgsql_dumptree(), plpgsql_error_funcname, PLPGSQL_EVENT_TRIGGER, plpgsql_extra_errors, plpgsql_extra_warnings, plpgsql_finish_datums(), plpgsql_HashTableInsert(), PLPGSQL_LABEL_BLOCK, PLPGSQL_NOT_TRIGGER, plpgsql_ns_init(), plpgsql_ns_push(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, plpgsql_parse_result, plpgsql_print_strict_params, PLPGSQL_PROMISE_TG_ARGV, PLPGSQL_PROMISE_TG_EVENT, PLPGSQL_PROMISE_TG_LEVEL, PLPGSQL_PROMISE_TG_NAME, PLPGSQL_PROMISE_TG_NARGS, PLPGSQL_PROMISE_TG_OP, PLPGSQL_PROMISE_TG_RELID, PLPGSQL_PROMISE_TG_TABLE_NAME, PLPGSQL_PROMISE_TG_TABLE_SCHEMA, PLPGSQL_PROMISE_TG_TAG, PLPGSQL_PROMISE_TG_WHEN, plpgsql_resolve_polymorphic_argtypes(), plpgsql_scanner_finish(), plpgsql_scanner_init(), plpgsql_start_datums(), PLPGSQL_TTYPE_PSEUDO, plpgsql_variable_conflict, plpgsql_yyparse(), ErrorContextCallback::previous, compile_error_callback_arg::proc_source, pstrdup(), ReleaseSysCache(), SearchSysCache1(), snprintf, SysCacheGetAttrNotNull(), HeapTupleData::t_data, HeapTupleData::t_self, TextDatumGetCString, TopMemoryContext, PLpgSQL_type::ttype, type_is_rowtype(), and compile_error_callback_arg::yyscanner.

Referenced by plpgsql_compile().

make_datum_param()

static Node * make_datum_param ( PLpgSQL_expr *  expr, int  dno, int  location  )

static

Definition at line 1345 of file pl_comp.c.

{
    PLpgSQL_execstate *estate;
    PLpgSQL_datum *datum;
    Param      *param;
    MemoryContext oldcontext;
 
    /* see comment in resolve_column_ref */
    estate = expr->func->cur_estate;
    Assert(dno >= 0 && dno < estate->ndatums);
    datum = estate->datums[dno];
 
    /*
     * Bitmapset must be allocated in function's permanent memory context
     */
    oldcontext = MemoryContextSwitchTo(expr->func->fn_cxt);
    expr->paramnos = bms_add_member(expr->paramnos, dno);
    MemoryContextSwitchTo(oldcontext);
 
    param = makeNode(Param);
    param->paramkind = PARAM_EXTERN;
    param->paramid = dno + 1;
    plpgsql_exec_get_datum_type_info(estate,
                                     datum,
                                     &param->paramtype,
                                     &param->paramtypmod,
                                     &param->paramcollid);
    param->location = location;
 
    return (Node *) param;
}

References Assert, bms_add_member(), PLpgSQL_function::cur_estate, PLpgSQL_execstate::datums, PLpgSQL_function::fn_cxt, PLpgSQL_expr::func, Param::location, makeNode, MemoryContextSwitchTo(), PARAM_EXTERN, Param::paramid, Param::paramkind, PLpgSQL_expr::paramnos, Param::paramtype, and plpgsql_exec_get_datum_type_info().

Referenced by plpgsql_param_ref(), and resolve_column_ref().

plpgsql_add_initdatums()

int plpgsql_add_initdatums

(

int **

varnos

)

Definition at line 2386 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 2325 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 do_compile(), plpgsql_build_recfield(), plpgsql_build_record(), and plpgsql_build_variable().

plpgsql_build_datatype()

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

Definition at line 2056 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 do_compile(), exec_stmt_case(), plpgsql_build_datatype_arrayof(), 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 2190 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 2009 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 1915 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 do_compile(), and plpgsql_build_variable().

plpgsql_build_variable()

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

Definition at line 1852 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 do_compile(), and plpgsql_compile_inline().

plpgsql_compile()

PLpgSQL_function * plpgsql_compile	(	FunctionCallInfo	fcinfo,
		bool	forValidator
	)

Definition at line 135 of file pl_comp.c.

{
    Oid         funcOid = fcinfo->flinfo->fn_oid;
    HeapTuple   procTup;
    Form_pg_proc procStruct;
    PLpgSQL_function *function;
    PLpgSQL_func_hashkey hashkey;
    bool        function_valid = false;
    bool        hashkey_valid = false;
 
    /*
     * Lookup the pg_proc tuple by Oid; we'll need it in any case
     */
    procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcOid));
    if (!HeapTupleIsValid(procTup))
        elog(ERROR, "cache lookup failed for function %u", funcOid);
    procStruct = (Form_pg_proc) GETSTRUCT(procTup);
 
    /*
     * See if there's already a cache entry for the current FmgrInfo. If not,
     * try to find one in the hash table.
     */
    function = (PLpgSQL_function *) fcinfo->flinfo->fn_extra;
 
recheck:
    if (!function)
    {
        /* Compute hashkey using function signature and actual arg types */
        compute_function_hashkey(fcinfo, procStruct, &hashkey, forValidator);
        hashkey_valid = true;
 
        /* And do the lookup */
        function = plpgsql_HashTableLookup(&hashkey);
    }
 
    if (function)
    {
        /* We have a compiled function, but is it still valid? */
        if (function->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
            ItemPointerEquals(&function->fn_tid, &procTup->t_self))
            function_valid = true;
        else
        {
            /*
             * Nope, so remove it from hashtable and try to drop associated
             * storage (if not done already).
             */
            delete_function(function);
 
            /*
             * If the function isn't in active use then we can overwrite the
             * func struct with new data, allowing any other existing fn_extra
             * pointers to make use of the new definition on their next use.
             * If it is in use then just leave it alone and make a new one.
             * (The active invocations will run to completion using the
             * previous definition, and then the cache entry will just be
             * leaked; doesn't seem worth adding code to clean it up, given
             * what a corner case this is.)
             *
             * If we found the function struct via fn_extra then it's possible
             * a replacement has already been made, so go back and recheck the
             * hashtable.
             */
            if (function->use_count != 0)
            {
                function = NULL;
                if (!hashkey_valid)
                    goto recheck;
            }
        }
    }
 
    /*
     * If the function wasn't found or was out-of-date, we have to compile it
     */
    if (!function_valid)
    {
        /*
         * Calculate hashkey if we didn't already; we'll need it to store the
         * completed function.
         */
        if (!hashkey_valid)
            compute_function_hashkey(fcinfo, procStruct, &hashkey,
                                     forValidator);
 
        /*
         * Do the hard part.
         */
        function = do_compile(fcinfo, procTup, function,
                              &hashkey, forValidator);
    }
 
    ReleaseSysCache(procTup);
 
    /*
     * Save pointer in FmgrInfo to avoid search on subsequent calls
     */
    fcinfo->flinfo->fn_extra = function;
 
    /*
     * Finally return the compiled function
     */
    return function;
}

References compute_function_hashkey(), delete_function(), do_compile(), elog, ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_oid, function, GETSTRUCT, HeapTupleHeaderGetRawXmin, HeapTupleIsValid, if(), ItemPointerEquals(), ObjectIdGetDatum(), plpgsql_HashTableLookup(), ReleaseSysCache(), SearchSysCache1(), HeapTupleData::t_data, and HeapTupleData::t_self.

Referenced by plpgsql_call_handler(), and plpgsql_validator().

plpgsql_compile_error_callback()

static void plpgsql_compile_error_callback ( void *  arg )

static

Definition at line 989 of file pl_comp.c.

{
    struct compile_error_callback_arg *cbarg = (struct compile_error_callback_arg *) arg;
    yyscan_t    yyscanner = cbarg->yyscanner;
 
    if (cbarg->proc_source)
    {
        /*
         * Try to convert syntax error position to reference text of original
         * CREATE FUNCTION or DO command.
         */
        if (function_parse_error_transpose(cbarg->proc_source))
            return;
 
        /*
         * Done if a syntax error position was reported; otherwise we have to
         * fall back to a "near line N" report.
         */
    }
 
    if (plpgsql_error_funcname)
        errcontext("compilation of PL/pgSQL function \"%s\" near line %d",
                   plpgsql_error_funcname, plpgsql_latest_lineno(yyscanner));
}

References arg, errcontext, function_parse_error_transpose(), plpgsql_error_funcname, plpgsql_latest_lineno(), compile_error_callback_arg::proc_source, and compile_error_callback_arg::yyscanner.

Referenced by do_compile(), and plpgsql_compile_inline().

plpgsql_compile_inline()

PLpgSQL_function * plpgsql_compile_inline

(

char *

proc_source

)

Definition at line 850 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;
 
    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(scanner);
    if (parse_rc != 0)
        elog(ERROR, "plpgsql parser returned %d", parse_rc);
    function->action = plpgsql_parse_result;
 
    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);
 
    /*
     * 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_error_funcname, plpgsql_finish_datums(), PLPGSQL_LABEL_BLOCK, PLPGSQL_NOT_TRIGGER, plpgsql_ns_init(), plpgsql_ns_push(), plpgsql_parse_result, 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_finish_datums()

static void plpgsql_finish_datums ( PLpgSQL_function *  function )

static

Definition at line 2342 of file pl_comp.c.

{
    Size        copiable_size = 0;
    int         i;
 
    function->ndatums = plpgsql_nDatums;
    function->datums = palloc(sizeof(PLpgSQL_datum *) * plpgsql_nDatums);
    for (i = 0; i < plpgsql_nDatums; i++)
    {
        function->datums[i] = plpgsql_Datums[i];
 
        /* This must agree with copy_plpgsql_datums on what is copiable */
        switch (function->datums[i]->dtype)
        {
            case PLPGSQL_DTYPE_VAR:
            case PLPGSQL_DTYPE_PROMISE:
                copiable_size += MAXALIGN(sizeof(PLpgSQL_var));
                break;
            case PLPGSQL_DTYPE_REC:
                copiable_size += MAXALIGN(sizeof(PLpgSQL_rec));
                break;
            default:
                break;
        }
    }
    function->copiable_size = copiable_size;
}

References function, i, MAXALIGN, palloc(), plpgsql_Datums, PLPGSQL_DTYPE_PROMISE, PLPGSQL_DTYPE_REC, PLPGSQL_DTYPE_VAR, and plpgsql_nDatums.

Referenced by do_compile(), and plpgsql_compile_inline().

plpgsql_HashTableDelete()

static void plpgsql_HashTableDelete ( PLpgSQL_function *  function )

static

Definition at line 2657 of file pl_comp.c.

{
    plpgsql_HashEnt *hentry;
 
    /* do nothing if not in table */
    if (function->fn_hashkey == NULL)
        return;
 
    hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
                                             function->fn_hashkey,
                                             HASH_REMOVE,
                                             NULL);
    if (hentry == NULL)
        elog(WARNING, "trying to delete function that does not exist");
 
    /* remove back link, which no longer points to allocated storage */
    function->fn_hashkey = NULL;
}

References elog, function, HASH_REMOVE, hash_search(), plpgsql_HashTable, and WARNING.

Referenced by delete_function().

plpgsql_HashTableInit()

void plpgsql_HashTableInit

(

void

)

Definition at line 2607 of file pl_comp.c.

{
    HASHCTL     ctl;
 
    /* don't allow double-initialization */
    Assert(plpgsql_HashTable == NULL);
 
    ctl.keysize = sizeof(PLpgSQL_func_hashkey);
    ctl.entrysize = sizeof(plpgsql_HashEnt);
    plpgsql_HashTable = hash_create("PLpgSQL function hash",
                                    FUNCS_PER_USER,
                                    &ctl,
                                    HASH_ELEM | HASH_BLOBS);
}

References Assert, ctl, FUNCS_PER_USER, HASH_BLOBS, hash_create(), HASH_ELEM, and plpgsql_HashTable.

Referenced by _PG_init().

plpgsql_HashTableInsert()

static void plpgsql_HashTableInsert ( PLpgSQL_function *  function, PLpgSQL_func_hashkey *  func_key  )

static

Definition at line 2638 of file pl_comp.c.

{
    plpgsql_HashEnt *hentry;
    bool        found;
 
    hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
                                             func_key,
                                             HASH_ENTER,
                                             &found);
    if (found)
        elog(WARNING, "trying to insert a function that already exists");
 
    hentry->function = function;
    /* prepare back link from function to hashtable key */
    function->fn_hashkey = &hentry->key;
}

References elog, function, plpgsql_hashent::function, HASH_ENTER, hash_search(), plpgsql_hashent::key, plpgsql_HashTable, and WARNING.

Referenced by do_compile().

plpgsql_HashTableLookup()

static PLpgSQL_function * plpgsql_HashTableLookup ( PLpgSQL_func_hashkey *  func_key )

static

Definition at line 2623 of file pl_comp.c.

{
    plpgsql_HashEnt *hentry;
 
    hentry = (plpgsql_HashEnt *) hash_search(plpgsql_HashTable,
                                             func_key,
                                             HASH_FIND,
                                             NULL);
    if (hentry)
        return hentry->function;
    else
        return NULL;
}

References plpgsql_hashent::function, HASH_FIND, hash_search(), and plpgsql_HashTable.

Referenced by plpgsql_compile().

plpgsql_param_ref()

static Node * plpgsql_param_ref ( ParseState *  pstate, ParamRef *  pref  )

static

Definition at line 1160 of file pl_comp.c.

{
    PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
    char        pname[32];
    PLpgSQL_nsitem *nse;
 
    snprintf(pname, sizeof(pname), "$%d", pref->number);
 
    nse = plpgsql_ns_lookup(expr->ns, false,
                            pname, NULL, NULL,
                            NULL);
 
    if (nse == NULL)
        return NULL;            /* name not known to plpgsql */
 
    return make_datum_param(expr, nse->itemno, pref->location);
}

References ParamRef::location, make_datum_param(), PLpgSQL_expr::ns, ParamRef::number, ParseState::p_ref_hook_state, plpgsql_ns_lookup(), and snprintf.

Referenced by plpgsql_parser_setup().

plpgsql_parse_cwordrowtype()

PLpgSQL_type * plpgsql_parse_cwordrowtype

(

List *

idents

)

Definition at line 1808 of file pl_comp.c.

{
    Oid         classOid;
    Oid         typOid;
    RangeVar   *relvar;
    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)));
 
    MemoryContextSwitchTo(oldCxt);
 
    /* Build and return the row type struct */
    return plpgsql_build_datatype(typOid, -1, InvalidOid,
                                  makeTypeNameFromNameList(idents));
}

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 1659 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 1453 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 2257 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.
     */
 
    /*
     * OTHERS is represented as code 0 (which would map to '00000', but we
     * have no need to represent that as an exception condition).
     */
    if (strcmp(condname, "others") == 0)
    {
        new = palloc(sizeof(PLpgSQL_condition));
        new->sqlerrstate = 0;
        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(), and ExceptionLabelMap::sqlerrstate.

plpgsql_parse_tripword()

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

Definition at line 1534 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 1398 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 1771 of file pl_comp.c.

{
    Oid         classOid;
    Oid         typOid;
 
    /*
     * 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)));
 
    /* Build and return the row type struct */
    return plpgsql_build_datatype(typOid, -1, InvalidOid,
                                  makeTypeName(ident));
}

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

plpgsql_parse_wordtype()

PLpgSQL_type * plpgsql_parse_wordtype

(

char *

ident

)

Definition at line 1618 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()

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

Definition at line 1089 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_post_column_ref()

static Node * plpgsql_post_column_ref ( ParseState *  pstate, ColumnRef *  cref, Node *  var  )

static

Definition at line 1116 of file pl_comp.c.

{
    PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
    Node       *myvar;
 
    if (expr->func->resolve_option == PLPGSQL_RESOLVE_VARIABLE)
        return NULL;            /* we already found there's no match */
 
    if (expr->func->resolve_option == PLPGSQL_RESOLVE_COLUMN && var != NULL)
        return NULL;            /* there's a table column, prefer that */
 
    /*
     * If we find a record/row variable but can't match a field name, throw
     * error if there was no core resolution for the ColumnRef either.  In
     * that situation, the reference is inevitably going to fail, and
     * complaining about the record/row variable is likely to be more on-point
     * than the core parser's error message.  (It's too bad we don't have
     * access to transformColumnRef's internal crerr state here, as in case of
     * a conflict with a table name this could still be less than the most
     * helpful error message possible.)
     */
    myvar = resolve_column_ref(pstate, expr, cref, (var == NULL));
 
    if (myvar != NULL && var != NULL)
    {
        /*
         * We could leave it to the core parser to throw this error, but we
         * can add a more useful detail message than the core could.
         */
        ereport(ERROR,
                (errcode(ERRCODE_AMBIGUOUS_COLUMN),
                 errmsg("column reference \"%s\" is ambiguous",
                        NameListToString(cref->fields)),
                 errdetail("It could refer to either a PL/pgSQL variable or a table column."),
                 parser_errposition(pstate, cref->location)));
    }
 
    return myvar;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, ColumnRef::fields, PLpgSQL_expr::func, if(), ColumnRef::location, NameListToString(), ParseState::p_ref_hook_state, parser_errposition(), PLPGSQL_RESOLVE_COLUMN, PLPGSQL_RESOLVE_VARIABLE, resolve_column_ref(), and PLpgSQL_function::resolve_option.

Referenced by plpgsql_parser_setup().

plpgsql_pre_column_ref()

static Node * plpgsql_pre_column_ref ( ParseState *  pstate, ColumnRef *  cref  )

static

Definition at line 1102 of file pl_comp.c.

{
    PLpgSQL_expr *expr = (PLpgSQL_expr *) pstate->p_ref_hook_state;
 
    if (expr->func->resolve_option == PLPGSQL_RESOLVE_VARIABLE)
        return resolve_column_ref(pstate, expr, cref, false);
    else
        return NULL;
}

References PLpgSQL_expr::func, if(), ParseState::p_ref_hook_state, PLPGSQL_RESOLVE_VARIABLE, resolve_column_ref(), and PLpgSQL_function::resolve_option.

Referenced by plpgsql_parser_setup().

plpgsql_recognize_err_condition()

int plpgsql_recognize_err_condition	(	const char *	condname,
		bool	allow_sqlstate
	)

Definition at line 2221 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_resolve_polymorphic_argtypes()

static void plpgsql_resolve_polymorphic_argtypes ( int  numargs, Oid *  argtypes, char *  argmodes, Node *  call_expr, bool  forValidator, const char *  proname  )

static

Definition at line 2510 of file pl_comp.c.

{
    int         i;
 
    if (!forValidator)
    {
        int         inargno;
 
        /* normal case, pass to standard routine */
        if (!resolve_polymorphic_argtypes(numargs, argtypes, argmodes,
                                          call_expr))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("could not determine actual argument "
                            "type for polymorphic function \"%s\"",
                            proname)));
        /* also, treat RECORD inputs (but not outputs) as polymorphic */
        inargno = 0;
        for (i = 0; i < numargs; i++)
        {
            char        argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
 
            if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                continue;
            if (argtypes[i] == RECORDOID || argtypes[i] == RECORDARRAYOID)
            {
                Oid         resolvedtype = get_call_expr_argtype(call_expr,
                                                                 inargno);
 
                if (OidIsValid(resolvedtype))
                    argtypes[i] = resolvedtype;
            }
            inargno++;
        }
    }
    else
    {
        /* special validation case (no need to do anything for RECORD) */
        for (i = 0; i < numargs; i++)
        {
            switch (argtypes[i])
            {
                case ANYELEMENTOID:
                case ANYNONARRAYOID:
                case ANYENUMOID:    /* XXX dubious */
                case ANYCOMPATIBLEOID:
                case ANYCOMPATIBLENONARRAYOID:
                    argtypes[i] = INT4OID;
                    break;
                case ANYARRAYOID:
                case ANYCOMPATIBLEARRAYOID:
                    argtypes[i] = INT4ARRAYOID;
                    break;
                case ANYRANGEOID:
                case ANYCOMPATIBLERANGEOID:
                    argtypes[i] = INT4RANGEOID;
                    break;
                case ANYMULTIRANGEOID:
                    argtypes[i] = INT4MULTIRANGEOID;
                    break;
                default:
                    break;
            }
        }
    }
}

References ereport, errcode(), errmsg(), ERROR, get_call_expr_argtype(), i, OidIsValid, proname, and resolve_polymorphic_argtypes().

Referenced by compute_function_hashkey(), and do_compile().

plpgsql_start_datums()

static void plpgsql_start_datums ( void  )

static

Definition at line 2308 of file pl_comp.c.

{
    datums_alloc = 128;
    plpgsql_nDatums = 0;
    /* This is short-lived, so needn't allocate in function's cxt */
    plpgsql_Datums = MemoryContextAlloc(plpgsql_compile_tmp_cxt,
                                        sizeof(PLpgSQL_datum *) * datums_alloc);
    /* datums_last tracks what's been seen by plpgsql_add_initdatums() */
    datums_last = 0;
}

References datums_alloc, datums_last, MemoryContextAlloc(), plpgsql_compile_tmp_cxt, plpgsql_Datums, and plpgsql_nDatums.

Referenced by do_compile(), and plpgsql_compile_inline().

resolve_column_ref()

static Node * resolve_column_ref ( ParseState *  pstate, PLpgSQL_expr *  expr, ColumnRef *  cref, bool  error_if_no_field  )

static

Definition at line 1187 of file pl_comp.c.

{
    PLpgSQL_execstate *estate;
    PLpgSQL_nsitem *nse;
    const char *name1;
    const char *name2 = NULL;
    const char *name3 = NULL;
    const char *colname = NULL;
    int         nnames;
    int         nnames_scalar = 0;
    int         nnames_wholerow = 0;
    int         nnames_field = 0;
 
    /*
     * We use the function's current estate to resolve parameter data types.
     * This is really pretty bogus because there is no provision for updating
     * plans when those types change ...
     */
    estate = expr->func->cur_estate;
 
    /*----------
     * The allowed syntaxes are:
     *
     * A        Scalar variable reference, or whole-row record reference.
     * A.B      Qualified scalar or whole-row reference, or field reference.
     * A.B.C    Qualified record field reference.
     * A.*      Whole-row record reference.
     * A.B.*    Qualified whole-row record reference.
     *----------
     */
    switch (list_length(cref->fields))
    {
        case 1:
            {
                Node       *field1 = (Node *) linitial(cref->fields);
 
                name1 = strVal(field1);
                nnames_scalar = 1;
                nnames_wholerow = 1;
                break;
            }
        case 2:
            {
                Node       *field1 = (Node *) linitial(cref->fields);
                Node       *field2 = (Node *) lsecond(cref->fields);
 
                name1 = strVal(field1);
 
                /* Whole-row reference? */
                if (IsA(field2, A_Star))
                {
                    /* Set name2 to prevent matches to scalar variables */
                    name2 = "*";
                    nnames_wholerow = 1;
                    break;
                }
 
                name2 = strVal(field2);
                colname = name2;
                nnames_scalar = 2;
                nnames_wholerow = 2;
                nnames_field = 1;
                break;
            }
        case 3:
            {
                Node       *field1 = (Node *) linitial(cref->fields);
                Node       *field2 = (Node *) lsecond(cref->fields);
                Node       *field3 = (Node *) lthird(cref->fields);
 
                name1 = strVal(field1);
                name2 = strVal(field2);
 
                /* Whole-row reference? */
                if (IsA(field3, A_Star))
                {
                    /* Set name3 to prevent matches to scalar variables */
                    name3 = "*";
                    nnames_wholerow = 2;
                    break;
                }
 
                name3 = strVal(field3);
                colname = name3;
                nnames_field = 2;
                break;
            }
        default:
            /* too many names, ignore */
            return NULL;
    }
 
    nse = plpgsql_ns_lookup(expr->ns, false,
                            name1, name2, name3,
                            &nnames);
 
    if (nse == NULL)
        return NULL;            /* name not known to plpgsql */
 
    switch (nse->itemtype)
    {
        case PLPGSQL_NSTYPE_VAR:
            if (nnames == nnames_scalar)
                return make_datum_param(expr, nse->itemno, cref->location);
            break;
        case PLPGSQL_NSTYPE_REC:
            if (nnames == nnames_wholerow)
                return make_datum_param(expr, nse->itemno, cref->location);
            if (nnames == nnames_field)
            {
                /* colname could be a field in this record */
                PLpgSQL_rec *rec = (PLpgSQL_rec *) estate->datums[nse->itemno];
                int         i;
 
                /* search for a datum referencing this field */
                i = rec->firstfield;
                while (i >= 0)
                {
                    PLpgSQL_recfield *fld = (PLpgSQL_recfield *) estate->datums[i];
 
                    Assert(fld->dtype == PLPGSQL_DTYPE_RECFIELD &&
                           fld->recparentno == nse->itemno);
                    if (strcmp(fld->fieldname, colname) == 0)
                    {
                        return make_datum_param(expr, i, cref->location);
                    }
                    i = fld->nextfield;
                }
 
                /*
                 * We should not get here, because a RECFIELD datum should
                 * have been built at parse time for every possible qualified
                 * reference to fields of this record.  But if we do, handle
                 * it like field-not-found: throw error or return NULL.
                 */
                if (error_if_no_field)
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_COLUMN),
                             errmsg("record \"%s\" has no field \"%s\"",
                                    (nnames_field == 1) ? name1 : name2,
                                    colname),
                             parser_errposition(pstate, cref->location)));
            }
            break;
        default:
            elog(ERROR, "unrecognized plpgsql itemtype: %d", nse->itemtype);
    }
 
    /* Name format doesn't match the plpgsql variable type */
    return NULL;
}

References Assert, PLpgSQL_function::cur_estate, PLpgSQL_execstate::datums, PLpgSQL_recfield::dtype, elog, ereport, errcode(), errmsg(), ERROR, PLpgSQL_recfield::fieldname, ColumnRef::fields, PLpgSQL_rec::firstfield, PLpgSQL_expr::func, i, IsA, PLpgSQL_nsitem::itemno, PLpgSQL_nsitem::itemtype, linitial, list_length(), ColumnRef::location, lsecond, lthird, make_datum_param(), PLpgSQL_recfield::nextfield, PLpgSQL_expr::ns, parser_errposition(), PLPGSQL_DTYPE_RECFIELD, plpgsql_ns_lookup(), PLPGSQL_NSTYPE_REC, PLPGSQL_NSTYPE_VAR, PLpgSQL_recfield::recparentno, strVal, and while().

Referenced by plpgsql_post_column_ref(), and plpgsql_pre_column_ref().

Variable Documentation

datums_alloc

int datums_alloc

static

Definition at line 43 of file pl_comp.c.

Referenced by plpgsql_adddatum(), and plpgsql_start_datums().

datums_last

int datums_last

static

Definition at line 46 of file pl_comp.c.

Referenced by plpgsql_add_initdatums(), and plpgsql_start_datums().

exception_label_map

const ExceptionLabelMap exception_label_map[]

static

Initial value:

= {
 
    {NULL, 0}
}

Definition at line 81 of file pl_comp.c.

Referenced by plpgsql_parse_err_condition(), and plpgsql_recognize_err_condition().

plpgsql_check_syntax

bool plpgsql_check_syntax = false

Definition at line 50 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().

plpgsql_compile_tmp_cxt

MemoryContext plpgsql_compile_tmp_cxt

Definition at line 55 of file pl_comp.c.

Referenced by do_compile(), plpgsql_compile_inline(), plpgsql_parse_cwordrowtype(), plpgsql_parse_cwordtype(), and plpgsql_start_datums().

plpgsql_curr_compile

PLpgSQL_function* plpgsql_curr_compile

Definition at line 52 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().

plpgsql_Datums

PLpgSQL_datum** plpgsql_Datums

Definition at line 45 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 = false

Definition at line 49 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().

plpgsql_error_funcname

char* plpgsql_error_funcname

Definition at line 48 of file pl_comp.c.

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

plpgsql_HashTable

HTAB* plpgsql_HashTable = NULL

static

Definition at line 61 of file pl_comp.c.

Referenced by plpgsql_HashTableDelete(), plpgsql_HashTableInit(), plpgsql_HashTableInsert(), and plpgsql_HashTableLookup().

plpgsql_nDatums

int plpgsql_nDatums

Definition at line 44 of file pl_comp.c.

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

plpgsql_parse_result

PLpgSQL_stmt_block* plpgsql_parse_result

Definition at line 41 of file pl_comp.c.

Referenced by do_compile(), and plpgsql_compile_inline().