*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.138 2006/07/31 20:09:04 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.139 2006/08/04 21:33:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* CreateExecutorState Create/delete executor working state
* FreeExecutorState
* CreateExprContext
+ * CreateStandaloneExprContext
* FreeExprContext
* ReScanExprContext
*
return econtext;
}
+/* ----------------
+ * CreateStandaloneExprContext
+ *
+ * Create a context for standalone expression evaluation.
+ *
+ * An ExprContext made this way can be used for evaluation of expressions
+ * that contain no Params, subplans, or Var references (it might work to
+ * put tuple references into the scantuple field, but it seems unwise).
+ *
+ * The ExprContext struct is allocated in the caller's current memory
+ * context, which also becomes its "per query" context.
+ *
+ * It is caller's responsibility to free the ExprContext when done,
+ * or at least ensure that any shutdown callbacks have been called
+ * (ReScanExprContext() is suitable). Otherwise, non-memory resources
+ * might be leaked.
+ * ----------------
+ */
+ExprContext *
+CreateStandaloneExprContext(void)
+{
+ ExprContext *econtext;
+
+ /* Create the ExprContext node within the caller's memory context */
+ econtext = makeNode(ExprContext);
+
+ /* Initialize fields of ExprContext */
+ econtext->ecxt_scantuple = NULL;
+ econtext->ecxt_innertuple = NULL;
+ econtext->ecxt_outertuple = NULL;
+
+ econtext->ecxt_per_query_memory = CurrentMemoryContext;
+
+ /*
+ * Create working memory for expression evaluation in this context.
+ */
+ econtext->ecxt_per_tuple_memory =
+ AllocSetContextCreate(CurrentMemoryContext,
+ "ExprContext",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+
+ econtext->ecxt_param_exec_vals = NULL;
+ econtext->ecxt_param_list_info = NULL;
+
+ econtext->ecxt_aggvalues = NULL;
+ econtext->ecxt_aggnulls = NULL;
+
+ econtext->caseValue_datum = (Datum) 0;
+ econtext->caseValue_isNull = true;
+
+ econtext->domainValue_datum = (Datum) 0;
+ econtext->domainValue_isNull = true;
+
+ econtext->ecxt_estate = NULL;
+
+ econtext->ecxt_callbacks = NULL;
+
+ return econtext;
+}
+
/* ----------------
* FreeExprContext
*
ShutdownExprContext(econtext);
/* And clean up the memory used */
MemoryContextDelete(econtext->ecxt_per_tuple_memory);
- /* Unlink self from owning EState */
+ /* Unlink self from owning EState, if any */
estate = econtext->ecxt_estate;
- estate->es_exprcontexts = list_delete_ptr(estate->es_exprcontexts, econtext);
+ if (estate)
+ estate->es_exprcontexts = list_delete_ptr(estate->es_exprcontexts,
+ econtext);
/* And delete the ExprContext node */
pfree(econtext);
}
*
* The overhead required for constraint checking can be high, since examining
* the catalogs to discover the constraints for a given domain is not cheap.
- * We have two mechanisms for minimizing this cost:
+ * We have three mechanisms for minimizing this cost:
* 1. In a nest of domains, we flatten the checking of all the levels
* into just one operation.
* 2. We cache the list of constraint items in the FmgrInfo struct
* passed by the caller.
- *
- * We also have to create an EState to evaluate CHECK expressions in.
- * Creating and destroying an EState is somewhat expensive, and so it's
- * tempting to cache the EState too. However, that would mean that the
- * EState never gets an explicit FreeExecutorState call, which is a bad idea
- * because it risks leaking non-memory resources.
+ * 3. If there are CHECK constraints, we cache a standalone ExprContext
+ * to evaluate them in.
*
*
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/domains.c,v 1.2 2006/07/14 14:52:24 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/domains.c,v 1.3 2006/08/04 21:33:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
FmgrInfo proc;
/* List of constraint items to check */
List *constraint_list;
+ /* Context for evaluating CHECK constraints in */
+ ExprContext *econtext;
+ /* Memory context this cache is in */
+ MemoryContext mcxt;
} DomainIOData;
my_extra->constraint_list = GetDomainConstraints(domainType);
MemoryContextSwitchTo(oldcontext);
+ /* We don't make an ExprContext until needed */
+ my_extra->econtext = NULL;
+ my_extra->mcxt = mcxt;
+
/* Mark cache valid */
my_extra->domain_type = domainType;
}
static void
domain_check_input(Datum value, bool isnull, DomainIOData *my_extra)
{
- EState *estate = NULL;
+ ExprContext *econtext = my_extra->econtext;
ListCell *l;
foreach(l, my_extra->constraint_list)
break;
case DOM_CONSTRAINT_CHECK:
{
- ExprContext *econtext;
Datum conResult;
bool conIsNull;
- Datum save_datum;
- bool save_isNull;
- if (estate == NULL)
- estate = CreateExecutorState();
- econtext = GetPerTupleExprContext(estate);
+ /* Make the econtext if we didn't already */
+ if (econtext == NULL)
+ {
+ MemoryContext oldcontext;
+
+ oldcontext = MemoryContextSwitchTo(my_extra->mcxt);
+ econtext = CreateStandaloneExprContext();
+ MemoryContextSwitchTo(oldcontext);
+ my_extra->econtext = econtext;
+ }
/*
* Set up value to be returned by CoerceToDomainValue
- * nodes. We must save and restore prior setting of
- * econtext's domainValue fields, in case this node is
- * itself within a check expression for another domain.
+ * nodes. Unlike ExecEvalCoerceToDomain, this econtext
+ * couldn't be shared with anything else, so no need
+ * to save and restore fields.
*/
- save_datum = econtext->domainValue_datum;
- save_isNull = econtext->domainValue_isNull;
-
econtext->domainValue_datum = value;
econtext->domainValue_isNull = isnull;
errmsg("value for domain %s violates check constraint \"%s\"",
format_type_be(my_extra->domain_type),
con->name)));
- econtext->domainValue_datum = save_datum;
- econtext->domainValue_isNull = save_isNull;
-
break;
}
default:
}
}
- if (estate)
- FreeExecutorState(estate);
+ /*
+ * Before exiting, call any shutdown callbacks and reset econtext's
+ * per-tuple memory. This avoids leaking non-memory resources,
+ * if anything in the expression(s) has any.
+ */
+ if (econtext)
+ ReScanExprContext(econtext);
}
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.127 2006/06/16 18:42:23 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.128 2006/08/04 21:33:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern EState *CreateExecutorState(void);
extern void FreeExecutorState(EState *estate);
extern ExprContext *CreateExprContext(EState *estate);
+extern ExprContext *CreateStandaloneExprContext(void);
extern void FreeExprContext(ExprContext *econtext);
extern void ReScanExprContext(ExprContext *econtext);
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/nodes/execnodes.h,v 1.157 2006/08/02 18:58:21 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/execnodes.h,v 1.158 2006/08/04 21:33:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Datum domainValue_datum;
bool domainValue_isNull;
- /* Link to containing EState */
+ /* Link to containing EState (NULL if a standalone ExprContext) */
struct EState *ecxt_estate;
/* Functions to call back when ExprContext is shut down */
projects / postgresql.git / commitdiff