diff --git a/src/pl/plpgsql/src/gram.y b/src/pl/plpgsql/src/gram.y index a28c6707e4670be17ed1c947d383f1d11b9c90c5..0963efe1b5b5e7e974a682d2a7f71d6427180e9b 100644 *** a/src/pl/plpgsql/src/gram.y --- b/src/pl/plpgsql/src/gram.y *************** decl_statement : decl_varname decl_const *** 490,495 **** --- 490,496 ---- curname_def = palloc0(sizeof(PLpgSQL_expr)); curname_def->dtype = PLPGSQL_DTYPE_EXPR; + curname_def->expr_num = plpgsql_nExprs++; strcpy(buf, "SELECT "); cp1 = new->refname; cp2 = buf + strlen(buf); *************** read_sql_construct(int until, *** 2277,2282 **** --- 2278,2284 ---- expr->query = pstrdup(ds.data); expr->plan = NULL; expr->paramnos = NULL; + expr->expr_num = plpgsql_nExprs++; expr->ns = plpgsql_ns_top(); pfree(ds.data); *************** make_execsql_stmt(int firsttoken, int lo *** 2476,2481 **** --- 2478,2484 ---- expr->query = pstrdup(ds.data); expr->plan = NULL; expr->paramnos = NULL; + expr->expr_num = plpgsql_nExprs++; expr->ns = plpgsql_ns_top(); pfree(ds.data); diff --git a/src/pl/plpgsql/src/pl_comp.c b/src/pl/plpgsql/src/pl_comp.c index 3ddcf3b5a595e0847627cc10c4084258f44cc352..4feb14d2bec87de5d8a66071ab3a66da3c2a2d76 100644 *** a/src/pl/plpgsql/src/pl_comp.c --- b/src/pl/plpgsql/src/pl_comp.c *************** *** 37,42 **** --- 37,47 ---- /* ---------- * Our own local and global variables + * + * Ideally these would live in some dynamically-allocated structure, but + * it's unpleasant to pass such a thing around in a Bison parser. As long + * as plpgsql function compilation isn't re-entrant, it's okay to use + * static storage for these. * ---------- */ PLpgSQL_stmt_block *plpgsql_parse_result; *************** int plpgsql_nDatums; *** 46,51 **** --- 51,58 ---- PLpgSQL_datum **plpgsql_Datums; static int datums_last = 0; + int plpgsql_nExprs; + char *plpgsql_error_funcname; bool plpgsql_DumpExecTree = false; bool plpgsql_check_syntax = false; *************** do_compile(FunctionCallInfo fcinfo, *** 367,372 **** --- 374,381 ---- sizeof(PLpgSQL_datum *) * datums_alloc); datums_last = 0; + plpgsql_nExprs = 0; + switch (is_trigger) { case false: *************** do_compile(FunctionCallInfo fcinfo, *** 693,698 **** --- 702,708 ---- function->datums = palloc(sizeof(PLpgSQL_datum *) * plpgsql_nDatums); for (i = 0; i < plpgsql_nDatums; i++) function->datums[i] = plpgsql_Datums[i]; + function->nexprs = plpgsql_nExprs; /* Debug dump for completed functions */ if (plpgsql_DumpExecTree) *************** plpgsql_compile_inline(char *proc_source *** 788,793 **** --- 798,804 ---- plpgsql_nDatums = 0; plpgsql_Datums = palloc(sizeof(PLpgSQL_datum *) * datums_alloc); datums_last = 0; + plpgsql_nExprs = 0; /* Set up as though in a function returning VOID */ function->fn_rettype = VOIDOID; *************** plpgsql_compile_inline(char *proc_source *** 838,843 **** --- 849,855 ---- function->datums = palloc(sizeof(PLpgSQL_datum *) * plpgsql_nDatums); for (i = 0; i < plpgsql_nDatums; i++) function->datums[i] = plpgsql_Datums[i]; + function->nexprs = plpgsql_nExprs; /* * Pop the error context stack diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c index 9929e04e57bbc7d08938765b7f506c05c07b772b..613b96c0cc43b60ce770ea239184f686287a996c 100644 *** a/src/pl/plpgsql/src/pl_exec.c --- b/src/pl/plpgsql/src/pl_exec.c *************** typedef struct *** 48,80 **** bool *freevals; /* which arguments are pfree-able */ } PreparedParamsData; - /* - * All plpgsql function executions within a single transaction share the same - * executor EState for evaluating "simple" expressions. Each function call - * creates its own "eval_econtext" ExprContext within this estate for - * per-evaluation workspace. eval_econtext is freed at normal function exit, - * and the EState is freed at transaction end (in case of error, we assume - * that the abort mechanisms clean it all up). Furthermore, any exception - * block within a function has to have its own eval_econtext separate from - * the containing function's, so that we can clean up ExprContext callbacks - * properly at subtransaction exit. We maintain a stack that tracks the - * individual econtexts so that we can clean up correctly at subxact exit. - * - * This arrangement is a bit tedious to maintain, but it's worth the trouble - * so that we don't have to re-prepare simple expressions on each trip through - * a function. (We assume the case to optimize is many repetitions of a - * function within a transaction.) - */ - typedef struct SimpleEcontextStackEntry - { - ExprContext *stack_econtext; /* a stacked econtext */ - SubTransactionId xact_subxid; /* ID for current subxact */ - struct SimpleEcontextStackEntry *next; /* next stack entry up */ - } SimpleEcontextStackEntry; - - static EState *simple_eval_estate = NULL; - static SimpleEcontextStackEntry *simple_econtext_stack = NULL; - /************************************************************ * Local function forward declarations ************************************************************/ --- 48,53 ---- *************** exec_stmt_block(PLpgSQL_execstate *estat *** 1013,1019 **** --- 986,994 ---- */ MemoryContext oldcontext = CurrentMemoryContext; ResourceOwner oldowner = CurrentResourceOwner; + EState *old_eval_estate = estate->eval_estate; ExprContext *old_eval_econtext = estate->eval_econtext; + ExprState **old_eval_exprtrees = estate->eval_exprtrees; ErrorData *save_cur_error = estate->cur_error; estate->err_text = gettext_noop("during statement block entry"); *************** exec_stmt_block(PLpgSQL_execstate *estat *** 1026,1034 **** { /* * We need to run the block's statements with a new eval_econtext ! * that belongs to the current subtransaction; if we try to use ! * the outer econtext then ExprContext shutdown callbacks will be ! * called at the wrong times. */ plpgsql_create_econtext(estate); --- 1001,1012 ---- { /* * We need to run the block's statements with a new eval_econtext ! * that is private to the current subtransaction. If we try to ! * share the outer econtext we won't be able to call ExprContext ! * shutdown callbacks for just the exprs used inside the ! * subtransaction. Also, we need to be able to release the ! * exprtrees on subtransaction failure, since they might contain ! * stale execution state in that case. */ plpgsql_create_econtext(estate); *************** exec_stmt_block(PLpgSQL_execstate *estat *** 1058,1075 **** resTypByVal, resTypLen); } /* Commit the inner transaction, return to outer xact context */ ReleaseCurrentSubTransaction(); MemoryContextSwitchTo(oldcontext); CurrentResourceOwner = oldowner; /* - * Revert to outer eval_econtext. (The inner one was - * automatically cleaned up during subxact exit.) - */ - estate->eval_econtext = old_eval_econtext; - - /* * AtEOSubXact_SPI() should not have popped any SPI context, but * just in case it did, make sure we remain connected. */ --- 1036,1053 ---- resTypByVal, resTypLen); } + /* Clean up the inner eval_econtext, and restore the outer */ + plpgsql_destroy_econtext(estate); + estate->eval_estate = old_eval_estate; + estate->eval_econtext = old_eval_econtext; + estate->eval_exprtrees = old_eval_exprtrees; + /* Commit the inner transaction, return to outer xact context */ ReleaseCurrentSubTransaction(); MemoryContextSwitchTo(oldcontext); CurrentResourceOwner = oldowner; /* * AtEOSubXact_SPI() should not have popped any SPI context, but * just in case it did, make sure we remain connected. */ *************** exec_stmt_block(PLpgSQL_execstate *estat *** 1092,1099 **** --- 1070,1088 ---- MemoryContextSwitchTo(oldcontext); CurrentResourceOwner = oldowner; + /* + * We don't want to run cleanup hooks for the inner eval_econtext, + * but we do want to free the memory it used. Beware of + * possibility that we failed during sub-commit after the inner + * econtext was already cleaned up. + */ + if (estate->eval_estate != old_eval_estate) + MemoryContextDelete(estate->eval_estate->es_query_cxt); + /* Revert to outer eval_econtext */ + estate->eval_estate = old_eval_estate; estate->eval_econtext = old_eval_econtext; + estate->eval_exprtrees = old_eval_exprtrees; /* * If AtEOSubXact_SPI() popped any SPI context of the subxact, it *************** plpgsql_estate_setup(PLpgSQL_execstate * *** 2670,2679 **** estate->datums = palloc(sizeof(PLpgSQL_datum *) * estate->ndatums); /* caller is expected to fill the datums array */ estate->eval_tuptable = NULL; estate->eval_processed = 0; estate->eval_lastoid = InvalidOid; - estate->eval_econtext = NULL; estate->cur_expr = NULL; estate->err_stmt = NULL; --- 2659,2671 ---- estate->datums = palloc(sizeof(PLpgSQL_datum *) * estate->ndatums); /* caller is expected to fill the datums array */ + estate->eval_estate = NULL; + estate->eval_econtext = NULL; + estate->eval_exprtrees = NULL; + estate->eval_tuptable = NULL; estate->eval_processed = 0; estate->eval_lastoid = InvalidOid; estate->cur_expr = NULL; estate->err_stmt = NULL; *************** plpgsql_estate_setup(PLpgSQL_execstate * *** 2682,2688 **** estate->plugin_info = NULL; /* ! * Create an EState and ExprContext for evaluation of simple expressions. */ plpgsql_create_econtext(estate); --- 2674,2680 ---- estate->plugin_info = NULL; /* ! * Initialize state for evaluation of simple expressions. */ plpgsql_create_econtext(estate); *************** exec_eval_simple_expr(PLpgSQL_execstate *** 4514,4520 **** Oid *rettype) { ExprContext *econtext = estate->eval_econtext; ! LocalTransactionId curlxid = MyProc->lxid; CachedPlanSource *plansource; CachedPlan *cplan; ParamListInfo paramLI; --- 4506,4512 ---- Oid *rettype) { ExprContext *econtext = estate->eval_econtext; ! ExprState **exprtree_p; CachedPlanSource *plansource; CachedPlan *cplan; ParamListInfo paramLI; *************** exec_eval_simple_expr(PLpgSQL_execstate *** 4546,4551 **** --- 4538,4545 ---- ReleaseCachedPlan(cplan, true); return false; } + /* Force rebuild of execution tree below */ + estate->eval_exprtrees[expr->expr_num] = NULL; } /* *************** exec_eval_simple_expr(PLpgSQL_execstate *** 4555,4568 **** /* * Prepare the expression for execution, if it's not been done already in ! * the current transaction. (This will be forced to happen if we called ! * exec_simple_check_plan above.) */ ! if (expr->expr_simple_lxid != curlxid) { ! expr->expr_simple_state = ExecPrepareExpr(expr->expr_simple_expr, ! simple_eval_estate); ! expr->expr_simple_lxid = curlxid; } /* --- 4549,4571 ---- /* * Prepare the expression for execution, if it's not been done already in ! * the current function. */ ! exprtree_p = &estate->eval_exprtrees[expr->expr_num]; ! if (*exprtree_p == NULL) { ! #if 0 ! *exprtree_p = ExecPrepareExpr(expr->expr_simple_expr, ! estate->eval_estate); ! #else ! MemoryContext oldcontext; ! ! oldcontext = MemoryContextSwitchTo(estate->eval_estate->es_query_cxt); ! ! *exprtree_p = ExecInitExpr(expr->expr_simple_expr, NULL); ! ! MemoryContextSwitchTo(oldcontext); ! #endif } /* *************** exec_eval_simple_expr(PLpgSQL_execstate *** 4599,4605 **** /* * Finally we can call the executor to evaluate the expression */ ! *result = ExecEvalExpr(expr->expr_simple_state, econtext, isNull, NULL); --- 4602,4608 ---- /* * Finally we can call the executor to evaluate the expression */ ! *result = ExecEvalExpr(*exprtree_p, econtext, isNull, NULL); *************** exec_simple_check_plan(PLpgSQL_expr *exp *** 5336,5348 **** return; /* ! * Yes - this is a simple expression. Mark it as such, and initialize ! * state to "not valid in current transaction". */ expr->expr_simple_expr = tle->expr; - expr->expr_simple_state = NULL; - expr->expr_simple_lxid = InvalidLocalTransactionId; - /* Also stash away the expression result type */ expr->expr_simple_type = exprType((Node *) tle->expr); } --- 5339,5348 ---- return; /* ! * Yes - this is a simple expression. Mark it as such, and also ! * remember the expression's result type. */ expr->expr_simple_expr = tle->expr; expr->expr_simple_type = exprType((Node *) tle->expr); } *************** exec_set_found(PLpgSQL_execstate *estate *** 5363,5491 **** /* * plpgsql_create_econtext --- create an eval_econtext for the current function - * - * We may need to create a new simple_eval_estate too, if there's not one - * already for the current transaction. The EState will be cleaned up at - * transaction end. */ static void plpgsql_create_econtext(PLpgSQL_execstate *estate) { - SimpleEcontextStackEntry *entry; - /* ! * Create an EState for evaluation of simple expressions, if there's not ! * one already in the current transaction. The EState is made a child of ! * TopTransactionContext so it will have the right lifespan. ! */ ! if (simple_eval_estate == NULL) ! { ! MemoryContext oldcontext; ! ! oldcontext = MemoryContextSwitchTo(TopTransactionContext); ! simple_eval_estate = CreateExecutorState(); ! MemoryContextSwitchTo(oldcontext); ! } ! ! /* ! * Create a child econtext for the current function. */ ! estate->eval_econtext = CreateExprContext(simple_eval_estate); /* ! * Make a stack entry so we can clean up the econtext at subxact end. ! * Stack entries are kept in TopTransactionContext for simplicity. */ ! entry = (SimpleEcontextStackEntry *) ! MemoryContextAlloc(TopTransactionContext, ! sizeof(SimpleEcontextStackEntry)); ! ! entry->stack_econtext = estate->eval_econtext; ! entry->xact_subxid = GetCurrentSubTransactionId(); ! ! entry->next = simple_econtext_stack; ! simple_econtext_stack = entry; } /* * plpgsql_destroy_econtext --- destroy function's econtext - * - * We check that it matches the top stack entry, and destroy the stack - * entry along with the context. */ static void plpgsql_destroy_econtext(PLpgSQL_execstate *estate) { ! SimpleEcontextStackEntry *next; ! ! Assert(simple_econtext_stack != NULL); ! Assert(simple_econtext_stack->stack_econtext == estate->eval_econtext); ! ! next = simple_econtext_stack->next; ! pfree(simple_econtext_stack); ! simple_econtext_stack = next; ! ! FreeExprContext(estate->eval_econtext, true); estate->eval_econtext = NULL; ! } ! ! /* ! * plpgsql_xact_cb --- post-transaction-commit-or-abort cleanup ! * ! * If a simple-expression EState was created in the current transaction, ! * it has to be cleaned up. ! */ ! void ! plpgsql_xact_cb(XactEvent event, void *arg) ! { ! /* ! * If we are doing a clean transaction shutdown, free the EState (so that ! * any remaining resources will be released correctly). In an abort, we ! * expect the regular abort recovery procedures to release everything of ! * interest. ! */ ! if (event != XACT_EVENT_ABORT) ! { ! /* Shouldn't be any econtext stack entries left at commit */ ! Assert(simple_econtext_stack == NULL); ! ! if (simple_eval_estate) ! FreeExecutorState(simple_eval_estate); ! simple_eval_estate = NULL; ! } ! else ! { ! simple_econtext_stack = NULL; ! simple_eval_estate = NULL; ! } ! } ! ! /* ! * plpgsql_subxact_cb --- post-subtransaction-commit-or-abort cleanup ! * ! * Make sure any simple-expression econtexts created in the current ! * subtransaction get cleaned up. We have to do this explicitly because ! * no other code knows which child econtexts of simple_eval_estate belong ! * to which level of subxact. ! */ ! void ! plpgsql_subxact_cb(SubXactEvent event, SubTransactionId mySubid, ! SubTransactionId parentSubid, void *arg) ! { ! if (event == SUBXACT_EVENT_START_SUB) ! return; ! ! while (simple_econtext_stack != NULL && ! simple_econtext_stack->xact_subxid == mySubid) ! { ! SimpleEcontextStackEntry *next; ! ! FreeExprContext(simple_econtext_stack->stack_econtext, ! (event == SUBXACT_EVENT_COMMIT_SUB)); ! next = simple_econtext_stack->next; ! pfree(simple_econtext_stack); ! simple_econtext_stack = next; ! } } /* --- 5363,5402 ---- /* * plpgsql_create_econtext --- create an eval_econtext for the current function */ static void plpgsql_create_econtext(PLpgSQL_execstate *estate) { /* ! * Create an EState and an ExprContext for evaluation of simple ! * expressions. These are children of the function's SPI-procedure memory ! * context, so they will live only until function exit. */ ! estate->eval_estate = CreateExecutorState(); ! estate->eval_econtext = CreateExprContext(estate->eval_estate); /* ! * Create space for per-PLpgSQL_expr expression evaluation state trees. ! * Only "simple" expressions will actually use their slots, but it's ! * easiest to allocate a slot for each one anyway. All storage for the ! * state trees is in the eval_estate's "per-query" context. */ ! estate->eval_exprtrees = (ExprState **) ! MemoryContextAllocZero(estate->eval_estate->es_query_cxt, ! estate->func->nexprs * sizeof(ExprState *)); } /* * plpgsql_destroy_econtext --- destroy function's econtext */ static void plpgsql_destroy_econtext(PLpgSQL_execstate *estate) { ! /* This frees the exprcontext and the eval state trees as well: */ ! FreeExecutorState(estate->eval_estate); ! estate->eval_estate = NULL; estate->eval_econtext = NULL; ! estate->eval_exprtrees = NULL; } /* diff --git a/src/pl/plpgsql/src/pl_handler.c b/src/pl/plpgsql/src/pl_handler.c index ee49d71d23f9d53ab686f29b89de8e85379b8368..f6485653bb296c728a2bac382e97fa010c8ab44e 100644 *** a/src/pl/plpgsql/src/pl_handler.c --- b/src/pl/plpgsql/src/pl_handler.c *************** _PG_init(void) *** 68,75 **** EmitWarningsOnPlaceholders("plpgsql"); plpgsql_HashTableInit(); - RegisterXactCallback(plpgsql_xact_cb, NULL); - RegisterSubXactCallback(plpgsql_subxact_cb, NULL); /* Set up a rendezvous point with optional instrumentation plugin */ plugin_ptr = (PLpgSQL_plugin **) find_rendezvous_variable("PLpgSQL_plugin"); --- 68,73 ---- diff --git a/src/pl/plpgsql/src/plpgsql.h b/src/pl/plpgsql/src/plpgsql.h index 5b174c49b8bcac4658ffd54fc4493e43221533e7..bf67ca45f98f640d4475e94343b76083c13c1cfe 100644 *** a/src/pl/plpgsql/src/plpgsql.h --- b/src/pl/plpgsql/src/plpgsql.h *************** typedef struct PLpgSQL_expr *** 200,205 **** --- 200,206 ---- char *query; SPIPlanPtr plan; Bitmapset *paramnos; /* all dnos referenced by this query */ + int expr_num; /* index in func's eval_exprtrees[] */ /* function containing this expr (not set until we first parse query) */ struct PLpgSQL_function *func; *************** typedef struct PLpgSQL_expr *** 211,224 **** Expr *expr_simple_expr; /* NULL means not a simple expr */ int expr_simple_generation; /* plancache generation we checked */ Oid expr_simple_type; /* result type Oid, if simple */ - - /* - * if expr is simple AND prepared in current transaction, - * expr_simple_state is valid. Test validity by seeing if expr_simple_lxid - * matches current LXID. - */ - ExprState *expr_simple_state; - LocalTransactionId expr_simple_lxid; } PLpgSQL_expr; --- 212,217 ---- *************** typedef struct PLpgSQL_function *** 675,680 **** --- 668,675 ---- PLpgSQL_datum **datums; PLpgSQL_stmt_block *action; + int nexprs; /* number of PLpgSQL_expr's in function */ + /* these fields change when the function is used */ struct PLpgSQL_execstate *cur_estate; unsigned long use_count; *************** typedef struct PLpgSQL_execstate *** 709,719 **** int ndatums; PLpgSQL_datum **datums; /* temporary state for results from evaluation of query or expr */ SPITupleTable *eval_tuptable; uint32 eval_processed; Oid eval_lastoid; - ExprContext *eval_econtext; /* for executing simple expressions */ PLpgSQL_expr *cur_expr; /* current query/expr being evaluated */ /* status information for error context reporting */ --- 704,718 ---- int ndatums; PLpgSQL_datum **datums; + /* state for evaluation of "simple" expressions */ + EState *eval_estate; /* EState for simple expressions */ + ExprContext *eval_econtext; /* ExprContext for simple expressions */ + ExprState **eval_exprtrees; /* array containing func->nexprs elements */ + /* temporary state for results from evaluation of query or expr */ SPITupleTable *eval_tuptable; uint32 eval_processed; Oid eval_lastoid; PLpgSQL_expr *cur_expr; /* current query/expr being evaluated */ /* status information for error context reporting */ *************** extern PLpgSQL_stmt_block *plpgsql_parse *** 815,820 **** --- 814,821 ---- extern int plpgsql_nDatums; extern PLpgSQL_datum **plpgsql_Datums; + extern int plpgsql_nExprs; + extern char *plpgsql_error_funcname; extern PLpgSQL_function *plpgsql_curr_compile; *************** extern Datum plpgsql_exec_function(PLpgS *** 875,883 **** FunctionCallInfo fcinfo); extern HeapTuple plpgsql_exec_trigger(PLpgSQL_function *func, TriggerData *trigdata); - extern void plpgsql_xact_cb(XactEvent event, void *arg); - extern void plpgsql_subxact_cb(SubXactEvent event, SubTransactionId mySubid, - SubTransactionId parentSubid, void *arg); extern Oid exec_get_datum_type(PLpgSQL_execstate *estate, PLpgSQL_datum *datum); extern Oid exec_get_rec_fieldtype(PLpgSQL_rec *rec, const char *fieldname, --- 876,881 ----