pl_handler.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "plpgsql.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/varlena.h"

Include dependency graph for pl_handler.c:

Go to the source code of this file.

Functions
static bool	plpgsql_extra_checks_check_hook (char **newvalue, void **extra, GucSource source)
static void	plpgsql_extra_warnings_assign_hook (const char *newvalue, void *extra)
static void	plpgsql_extra_errors_assign_hook (const char *newvalue, void *extra)
void	_PG_init (void)
	PG_FUNCTION_INFO_V1 (plpgsql_call_handler)
Datum	plpgsql_call_handler (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (plpgsql_inline_handler)
Datum	plpgsql_inline_handler (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (plpgsql_validator)
Datum	plpgsql_validator (PG_FUNCTION_ARGS)

Variables
	PG_MODULE_MAGIC
static const struct config_enum_entry	variable_conflict_options []
int	plpgsql_variable_conflict = PLPGSQL_RESOLVE_ERROR
bool	plpgsql_print_strict_params = false
bool	plpgsql_check_asserts = true
static char *	plpgsql_extra_warnings_string = NULL
static char *	plpgsql_extra_errors_string = NULL
int	plpgsql_extra_warnings
int	plpgsql_extra_errors
PLpgSQL_plugin **	plpgsql_plugin_ptr = NULL

Function Documentation

_PG_init()

void _PG_init

(

void

)

Definition at line 145 of file pl_handler.c.

{
    /* Be sure we do initialization only once (should be redundant now) */
    static bool inited = false;
 
    if (inited)
        return;
 
    pg_bindtextdomain(TEXTDOMAIN);
 
    DefineCustomEnumVariable("plpgsql.variable_conflict",
                             gettext_noop("Sets handling of conflicts between PL/pgSQL variable names and table column names."),
                             NULL,
                             &plpgsql_variable_conflict,
                             PLPGSQL_RESOLVE_ERROR,
                             variable_conflict_options,
                             PGC_SUSET, 0,
                             NULL, NULL, NULL);
 
    DefineCustomBoolVariable("plpgsql.print_strict_params",
                             gettext_noop("Print information about parameters in the DETAIL part of the error messages generated on INTO ... STRICT failures."),
                             NULL,
                             &plpgsql_print_strict_params,
                             false,
                             PGC_USERSET, 0,
                             NULL, NULL, NULL);
 
    DefineCustomBoolVariable("plpgsql.check_asserts",
                             gettext_noop("Perform checks given in ASSERT statements."),
                             NULL,
                             &plpgsql_check_asserts,
                             true,
                             PGC_USERSET, 0,
                             NULL, NULL, NULL);
 
    DefineCustomStringVariable("plpgsql.extra_warnings",
                               gettext_noop("List of programming constructs that should produce a warning."),
                               NULL,
                               &plpgsql_extra_warnings_string,
                               "none",
                               PGC_USERSET, GUC_LIST_INPUT,
                               plpgsql_extra_checks_check_hook,
                               plpgsql_extra_warnings_assign_hook,
                               NULL);
 
    DefineCustomStringVariable("plpgsql.extra_errors",
                               gettext_noop("List of programming constructs that should produce an error."),
                               NULL,
                               &plpgsql_extra_errors_string,
                               "none",
                               PGC_USERSET, GUC_LIST_INPUT,
                               plpgsql_extra_checks_check_hook,
                               plpgsql_extra_errors_assign_hook,
                               NULL);
 
    MarkGUCPrefixReserved("plpgsql");
 
    plpgsql_HashTableInit();
    RegisterXactCallback(plpgsql_xact_cb, NULL);
    RegisterSubXactCallback(plpgsql_subxact_cb, NULL);
 
    /* Set up a rendezvous point with optional instrumentation plugin */
    plpgsql_plugin_ptr = (PLpgSQL_plugin **) find_rendezvous_variable("PLpgSQL_plugin");
 
    inited = true;
}

References DefineCustomBoolVariable(), DefineCustomEnumVariable(), DefineCustomStringVariable(), find_rendezvous_variable(), gettext_noop, GUC_LIST_INPUT, MarkGUCPrefixReserved(), pg_bindtextdomain(), PGC_SUSET, PGC_USERSET, plpgsql_check_asserts, plpgsql_extra_checks_check_hook(), plpgsql_extra_errors_assign_hook(), plpgsql_extra_errors_string, plpgsql_extra_warnings_assign_hook(), plpgsql_extra_warnings_string, plpgsql_HashTableInit(), plpgsql_plugin_ptr, plpgsql_print_strict_params, PLPGSQL_RESOLVE_ERROR, plpgsql_subxact_cb(), plpgsql_variable_conflict, plpgsql_xact_cb(), RegisterSubXactCallback(), RegisterXactCallback(), TEXTDOMAIN, and variable_conflict_options.

PG_FUNCTION_INFO_V1() [1/3]

PG_FUNCTION_INFO_V1

(

plpgsql_call_handler

)

PG_FUNCTION_INFO_V1() [2/3]

PG_FUNCTION_INFO_V1

(

plpgsql_inline_handler

)

PG_FUNCTION_INFO_V1() [3/3]

PG_FUNCTION_INFO_V1

(

plpgsql_validator

)

plpgsql_call_handler()

Datum plpgsql_call_handler

(

PG_FUNCTION_ARGS

)

Definition at line 222 of file pl_handler.c.

{
    bool        nonatomic;
    PLpgSQL_function *func;
    PLpgSQL_execstate *save_cur_estate;
    ResourceOwner procedure_resowner;
    volatile Datum retval = (Datum) 0;
    int         rc;
 
    nonatomic = fcinfo->context &&
        IsA(fcinfo->context, CallContext) &&
        !castNode(CallContext, fcinfo->context)->atomic;
 
    /*
     * Connect to SPI manager
     */
    SPI_connect_ext(nonatomic ? SPI_OPT_NONATOMIC : 0);
 
    /* Find or compile the function */
    func = plpgsql_compile(fcinfo, false);
 
    /* Must save and restore prior value of cur_estate */
    save_cur_estate = func->cur_estate;
 
    /* Mark the function as busy, so it can't be deleted from under us */
    func->use_count++;
 
    /*
     * If we'll need a procedure-lifespan resowner to execute any CALL or DO
     * statements, create it now.  Since this resowner is not tied to any
     * parent, failing to free it would result in process-lifespan leaks.
     * Therefore, be very wary of adding any code between here and the PG_TRY
     * block.
     */
    procedure_resowner =
        (nonatomic && func->requires_procedure_resowner) ?
        ResourceOwnerCreate(NULL, "PL/pgSQL procedure resources") : NULL;
 
    PG_TRY();
    {
        /*
         * Determine if called as function or trigger and call appropriate
         * subhandler
         */
        if (CALLED_AS_TRIGGER(fcinfo))
            retval = PointerGetDatum(plpgsql_exec_trigger(func,
                                                          (TriggerData *) fcinfo->context));
        else if (CALLED_AS_EVENT_TRIGGER(fcinfo))
        {
            plpgsql_exec_event_trigger(func,
                                       (EventTriggerData *) fcinfo->context);
            /* there's no return value in this case */
        }
        else
            retval = plpgsql_exec_function(func, fcinfo,
                                           NULL, NULL,
                                           procedure_resowner,
                                           !nonatomic);
    }
    PG_FINALLY();
    {
        /* Decrement use-count, restore cur_estate */
        func->use_count--;
        func->cur_estate = save_cur_estate;
 
        /* Be sure to release the procedure resowner if any */
        if (procedure_resowner)
        {
            ReleaseAllPlanCacheRefsInOwner(procedure_resowner);
            ResourceOwnerDelete(procedure_resowner);
        }
    }
    PG_END_TRY();
 
    /*
     * Disconnect from SPI manager
     */
    if ((rc = SPI_finish()) != SPI_OK_FINISH)
        elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
 
    return retval;
}

References CALLED_AS_EVENT_TRIGGER, CALLED_AS_TRIGGER, castNode, PLpgSQL_function::cur_estate, elog, ERROR, IsA, PG_END_TRY, PG_FINALLY, PG_TRY, plpgsql_compile(), plpgsql_exec_event_trigger(), plpgsql_exec_function(), plpgsql_exec_trigger(), PointerGetDatum(), ReleaseAllPlanCacheRefsInOwner(), PLpgSQL_function::requires_procedure_resowner, ResourceOwnerCreate(), ResourceOwnerDelete(), SPI_connect_ext(), SPI_finish(), SPI_OK_FINISH, SPI_OPT_NONATOMIC, SPI_result_code_string(), and PLpgSQL_function::use_count.

plpgsql_extra_checks_check_hook()

static bool plpgsql_extra_checks_check_hook ( char **  newvalue, void **  extra, GucSource  source  )

static

Definition at line 60 of file pl_handler.c.

{
    char       *rawstring;
    List       *elemlist;
    ListCell   *l;
    int         extrachecks = 0;
    int        *myextra;
 
    if (pg_strcasecmp(*newvalue, "all") == 0)
        extrachecks = PLPGSQL_XCHECK_ALL;
    else if (pg_strcasecmp(*newvalue, "none") == 0)
        extrachecks = PLPGSQL_XCHECK_NONE;
    else
    {
        /* Need a modifiable copy of string */
        rawstring = pstrdup(*newvalue);
 
        /* Parse string into list of identifiers */
        if (!SplitIdentifierString(rawstring, ',', &elemlist))
        {
            /* syntax error in list */
            GUC_check_errdetail("List syntax is invalid.");
            pfree(rawstring);
            list_free(elemlist);
            return false;
        }
 
        foreach(l, elemlist)
        {
            char       *tok = (char *) lfirst(l);
 
            if (pg_strcasecmp(tok, "shadowed_variables") == 0)
                extrachecks |= PLPGSQL_XCHECK_SHADOWVAR;
            else if (pg_strcasecmp(tok, "too_many_rows") == 0)
                extrachecks |= PLPGSQL_XCHECK_TOOMANYROWS;
            else if (pg_strcasecmp(tok, "strict_multi_assignment") == 0)
                extrachecks |= PLPGSQL_XCHECK_STRICTMULTIASSIGNMENT;
            else if (pg_strcasecmp(tok, "all") == 0 || pg_strcasecmp(tok, "none") == 0)
            {
                GUC_check_errdetail("Key word \"%s\" cannot be combined with other key words.", tok);
                pfree(rawstring);
                list_free(elemlist);
                return false;
            }
            else
            {
                GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
                pfree(rawstring);
                list_free(elemlist);
                return false;
            }
        }
 
        pfree(rawstring);
        list_free(elemlist);
    }
 
    myextra = (int *) guc_malloc(LOG, sizeof(int));
    if (!myextra)
        return false;
    *myextra = extrachecks;
    *extra = myextra;
 
    return true;
}

References GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG, pfree(), pg_strcasecmp(), PLPGSQL_XCHECK_ALL, PLPGSQL_XCHECK_NONE, PLPGSQL_XCHECK_SHADOWVAR, PLPGSQL_XCHECK_STRICTMULTIASSIGNMENT, PLPGSQL_XCHECK_TOOMANYROWS, pstrdup(), and SplitIdentifierString().

Referenced by _PG_init().

plpgsql_extra_errors_assign_hook()

static void plpgsql_extra_errors_assign_hook ( const char *  newvalue, void *  extra  )

static

Definition at line 133 of file pl_handler.c.

{
    plpgsql_extra_errors = *((int *) extra);
}

References plpgsql_extra_errors.

Referenced by _PG_init().

plpgsql_extra_warnings_assign_hook()

static void plpgsql_extra_warnings_assign_hook ( const char *  newvalue, void *  extra  )

static

Definition at line 127 of file pl_handler.c.

{
    plpgsql_extra_warnings = *((int *) extra);
}

References plpgsql_extra_warnings.

Referenced by _PG_init().

plpgsql_inline_handler()

Datum plpgsql_inline_handler

(

PG_FUNCTION_ARGS

)

Definition at line 314 of file pl_handler.c.

{
    LOCAL_FCINFO(fake_fcinfo, 0);
    InlineCodeBlock *codeblock = castNode(InlineCodeBlock, DatumGetPointer(PG_GETARG_DATUM(0)));
    PLpgSQL_function *func;
    FmgrInfo    flinfo;
    EState     *simple_eval_estate;
    ResourceOwner simple_eval_resowner;
    Datum       retval;
    int         rc;
 
    /*
     * Connect to SPI manager
     */
    SPI_connect_ext(codeblock->atomic ? 0 : SPI_OPT_NONATOMIC);
 
    /* Compile the anonymous code block */
    func = plpgsql_compile_inline(codeblock->source_text);
 
    /* Mark the function as busy, just pro forma */
    func->use_count++;
 
    /*
     * Set up a fake fcinfo with just enough info to satisfy
     * plpgsql_exec_function().  In particular note that this sets things up
     * with no arguments passed.
     */
    MemSet(fake_fcinfo, 0, SizeForFunctionCallInfo(0));
    MemSet(&flinfo, 0, sizeof(flinfo));
    fake_fcinfo->flinfo = &flinfo;
    flinfo.fn_oid = InvalidOid;
    flinfo.fn_mcxt = CurrentMemoryContext;
 
    /*
     * Create a private EState and resowner for simple-expression execution.
     * Notice that these are NOT tied to transaction-level resources; they
     * must survive any COMMIT/ROLLBACK the DO block executes, since we will
     * unconditionally try to clean them up below.  (Hence, be wary of adding
     * anything that could fail between here and the PG_TRY block.)  See the
     * comments for shared_simple_eval_estate.
     *
     * Because this resowner isn't tied to the calling transaction, we can
     * also use it as the "procedure" resowner for any CALL statements.  That
     * helps reduce the opportunities for failure here.
     */
    simple_eval_estate = CreateExecutorState();
    simple_eval_resowner =
        ResourceOwnerCreate(NULL, "PL/pgSQL DO block simple expressions");
 
    /* And run the function */
    PG_TRY();
    {
        retval = plpgsql_exec_function(func, fake_fcinfo,
                                       simple_eval_estate,
                                       simple_eval_resowner,
                                       simple_eval_resowner,    /* see above */
                                       codeblock->atomic);
    }
    PG_CATCH();
    {
        /*
         * We need to clean up what would otherwise be long-lived resources
         * accumulated by the failed DO block, principally cached plans for
         * statements (which can be flushed by plpgsql_free_function_memory),
         * execution trees for simple expressions, which are in the private
         * EState, and cached-plan refcounts held by the private resowner.
         *
         * Before releasing the private EState, we must clean up any
         * simple_econtext_stack entries pointing into it, which we can do by
         * invoking the subxact callback.  (It will be called again later if
         * some outer control level does a subtransaction abort, but no harm
         * is done.)  We cheat a bit knowing that plpgsql_subxact_cb does not
         * pay attention to its parentSubid argument.
         */
        plpgsql_subxact_cb(SUBXACT_EVENT_ABORT_SUB,
                           GetCurrentSubTransactionId(),
                           0, NULL);
 
        /* Clean up the private EState and resowner */
        FreeExecutorState(simple_eval_estate);
        ReleaseAllPlanCacheRefsInOwner(simple_eval_resowner);
        ResourceOwnerDelete(simple_eval_resowner);
 
        /* Function should now have no remaining use-counts ... */
        func->use_count--;
        Assert(func->use_count == 0);
 
        /* ... so we can free subsidiary storage */
        plpgsql_free_function_memory(func);
 
        /* And propagate the error */
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    /* Clean up the private EState and resowner */
    FreeExecutorState(simple_eval_estate);
    ReleaseAllPlanCacheRefsInOwner(simple_eval_resowner);
    ResourceOwnerDelete(simple_eval_resowner);
 
    /* Function should now have no remaining use-counts ... */
    func->use_count--;
    Assert(func->use_count == 0);
 
    /* ... so we can free subsidiary storage */
    plpgsql_free_function_memory(func);
 
    /*
     * Disconnect from SPI manager
     */
    if ((rc = SPI_finish()) != SPI_OK_FINISH)
        elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
 
    return retval;
}

References Assert, InlineCodeBlock::atomic, castNode, CreateExecutorState(), CurrentMemoryContext, DatumGetPointer(), elog, ERROR, FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, FreeExecutorState(), GetCurrentSubTransactionId(), InvalidOid, LOCAL_FCINFO, MemSet, PG_CATCH, PG_END_TRY, PG_GETARG_DATUM, PG_RE_THROW, PG_TRY, plpgsql_compile_inline(), plpgsql_exec_function(), plpgsql_free_function_memory(), plpgsql_subxact_cb(), ReleaseAllPlanCacheRefsInOwner(), ResourceOwnerCreate(), ResourceOwnerDelete(), SizeForFunctionCallInfo, InlineCodeBlock::source_text, SPI_connect_ext(), SPI_finish(), SPI_OK_FINISH, SPI_OPT_NONATOMIC, SPI_result_code_string(), SUBXACT_EVENT_ABORT_SUB, and PLpgSQL_function::use_count.

plpgsql_validator()

Datum plpgsql_validator

(

PG_FUNCTION_ARGS

)

Definition at line 440 of file pl_handler.c.

{
    Oid         funcoid = PG_GETARG_OID(0);
    HeapTuple   tuple;
    Form_pg_proc proc;
    char        functyptype;
    int         numargs;
    Oid        *argtypes;
    char      **argnames;
    char       *argmodes;
    bool        is_dml_trigger = false;
    bool        is_event_trigger = false;
    int         i;
 
    if (!CheckFunctionValidatorAccess(fcinfo->flinfo->fn_oid, funcoid))
        PG_RETURN_VOID();
 
    /* Get the new function's pg_proc entry */
    tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcoid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for function %u", funcoid);
    proc = (Form_pg_proc) GETSTRUCT(tuple);
 
    functyptype = get_typtype(proc->prorettype);
 
    /* Disallow pseudotype result */
    /* except for TRIGGER, EVTTRIGGER, RECORD, VOID, or polymorphic */
    if (functyptype == TYPTYPE_PSEUDO)
    {
        if (proc->prorettype == TRIGGEROID)
            is_dml_trigger = true;
        else if (proc->prorettype == EVENT_TRIGGEROID)
            is_event_trigger = true;
        else if (proc->prorettype != RECORDOID &&
                 proc->prorettype != VOIDOID &&
                 !IsPolymorphicType(proc->prorettype))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("PL/pgSQL functions cannot return type %s",
                            format_type_be(proc->prorettype))));
    }
 
    /* Disallow pseudotypes in arguments (either IN or OUT) */
    /* except for RECORD and polymorphic */
    numargs = get_func_arg_info(tuple,
                                &argtypes, &argnames, &argmodes);
    for (i = 0; i < numargs; i++)
    {
        if (get_typtype(argtypes[i]) == TYPTYPE_PSEUDO)
        {
            if (argtypes[i] != RECORDOID &&
                !IsPolymorphicType(argtypes[i]))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("PL/pgSQL functions cannot accept type %s",
                                format_type_be(argtypes[i]))));
        }
    }
 
    /* Postpone body checks if !check_function_bodies */
    if (check_function_bodies)
    {
        LOCAL_FCINFO(fake_fcinfo, 0);
        FmgrInfo    flinfo;
        int         rc;
        TriggerData trigdata;
        EventTriggerData etrigdata;
 
        /*
         * Connect to SPI manager (is this needed for compilation?)
         */
        SPI_connect();
 
        /*
         * Set up a fake fcinfo with just enough info to satisfy
         * plpgsql_compile().
         */
        MemSet(fake_fcinfo, 0, SizeForFunctionCallInfo(0));
        MemSet(&flinfo, 0, sizeof(flinfo));
        fake_fcinfo->flinfo = &flinfo;
        flinfo.fn_oid = funcoid;
        flinfo.fn_mcxt = CurrentMemoryContext;
        if (is_dml_trigger)
        {
            MemSet(&trigdata, 0, sizeof(trigdata));
            trigdata.type = T_TriggerData;
            fake_fcinfo->context = (Node *) &trigdata;
        }
        else if (is_event_trigger)
        {
            MemSet(&etrigdata, 0, sizeof(etrigdata));
            etrigdata.type = T_EventTriggerData;
            fake_fcinfo->context = (Node *) &etrigdata;
        }
 
        /* Test-compile the function */
        plpgsql_compile(fake_fcinfo, true);
 
        /*
         * Disconnect from SPI manager
         */
        if ((rc = SPI_finish()) != SPI_OK_FINISH)
            elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
    }
 
    ReleaseSysCache(tuple);
 
    PG_RETURN_VOID();
}

References check_function_bodies, CheckFunctionValidatorAccess(), CurrentMemoryContext, elog, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, format_type_be(), get_func_arg_info(), get_typtype(), GETSTRUCT, HeapTupleIsValid, i, LOCAL_FCINFO, MemSet, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_VOID, plpgsql_compile(), ReleaseSysCache(), SearchSysCache1(), SizeForFunctionCallInfo, SPI_connect(), SPI_finish(), SPI_OK_FINISH, SPI_result_code_string(), EventTriggerData::type, and TriggerData::type.

Variable Documentation

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 34 of file pl_handler.c.

plpgsql_check_asserts

bool plpgsql_check_asserts = true

Definition at line 48 of file pl_handler.c.

Referenced by _PG_init(), and exec_stmt_assert().

plpgsql_extra_errors

int plpgsql_extra_errors

Definition at line 53 of file pl_handler.c.

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

plpgsql_extra_errors_string

char* plpgsql_extra_errors_string = NULL

static

Definition at line 51 of file pl_handler.c.

Referenced by _PG_init().

plpgsql_extra_warnings

int plpgsql_extra_warnings

Definition at line 52 of file pl_handler.c.

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

plpgsql_extra_warnings_string

char* plpgsql_extra_warnings_string = NULL

static

Definition at line 50 of file pl_handler.c.

Referenced by _PG_init().

plpgsql_plugin_ptr

PLpgSQL_plugin** plpgsql_plugin_ptr = NULL

Definition at line 56 of file pl_handler.c.

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

plpgsql_print_strict_params

bool plpgsql_print_strict_params = false

Definition at line 46 of file pl_handler.c.

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

plpgsql_variable_conflict

int plpgsql_variable_conflict = PLPGSQL_RESOLVE_ERROR

Definition at line 44 of file pl_handler.c.

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

variable_conflict_options

const struct config_enum_entry variable_conflict_options[]

static

Initial value:

= {
    {"error", PLPGSQL_RESOLVE_ERROR, false},
    {"use_variable", PLPGSQL_RESOLVE_VARIABLE, false},
    {"use_column", PLPGSQL_RESOLVE_COLUMN, false},
    {NULL, 0, false}
}

Definition at line 37 of file pl_handler.c.

Referenced by _PG_init().