#include "access/xact.h"
#include "mb/pg_wchar.h"
+#include "utils/memutils.h"
#include "plpython.h"
return NULL;
cursor->portalname = NULL;
cursor->closed = false;
- PLy_typeinfo_init(&cursor->result);
+ cursor->mcxt = AllocSetContextCreate(TopMemoryContext,
+ "PL/Python cursor context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+ PLy_typeinfo_init(&cursor->result, cursor->mcxt);
oldcontext = CurrentMemoryContext;
oldowner = CurrentResourceOwner;
elog(ERROR, "SPI_cursor_open() failed: %s",
SPI_result_code_string(SPI_result));
- cursor->portalname = PLy_strdup(portal->name);
+ cursor->portalname = MemoryContextStrdup(cursor->mcxt, portal->name);
PLy_spi_subtransaction_commit(oldcontext, oldowner);
}
return NULL;
cursor->portalname = NULL;
cursor->closed = false;
- PLy_typeinfo_init(&cursor->result);
+ cursor->mcxt = AllocSetContextCreate(TopMemoryContext,
+ "PL/Python cursor context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+ PLy_typeinfo_init(&cursor->result, cursor->mcxt);
oldcontext = CurrentMemoryContext;
oldowner = CurrentResourceOwner;
elog(ERROR, "SPI_cursor_open() failed: %s",
SPI_result_code_string(SPI_result));
- cursor->portalname = PLy_strdup(portal->name);
+ cursor->portalname = MemoryContextStrdup(cursor->mcxt, portal->name);
PLy_spi_subtransaction_commit(oldcontext, oldowner);
}
if (PortalIsValid(portal))
SPI_cursor_close(portal);
+ cursor->closed = true;
+ }
+ if (cursor->mcxt)
+ {
+ MemoryContextDelete(cursor->mcxt);
+ cursor->mcxt = NULL;
}
-
- PLy_free(cursor->portalname);
- cursor->portalname = NULL;
-
- PLy_typeinfo_dealloc(&cursor->result);
arg->ob_type->tp_free(arg);
}
char *portalname;
PLyTypeInfo result;
bool closed;
+ MemoryContext mcxt;
} PLyCursorObject;
extern void PLy_cursor_init_type(void);
MemoryContextSwitchTo(subtransactiondata->oldcontext);
CurrentResourceOwner = subtransactiondata->oldowner;
- PLy_free(subtransactiondata);
+ pfree(subtransactiondata);
}
}
flinfo.fn_mcxt = CurrentMemoryContext;
MemSet(&proc, 0, sizeof(PLyProcedure));
- proc.pyname = PLy_strdup("__plpython_inline_block");
+ proc.mcxt = AllocSetContextCreate(TopMemoryContext,
+ "__plpython_inline_block",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+ proc.pyname = MemoryContextStrdup(proc.mcxt, "__plpython_inline_block");
proc.langid = codeblock->langOid;
proc.result.out.d.typoid = VOIDOID;
return PLy_execution_contexts;
}
+MemoryContext
+PLy_get_scratch_context(PLyExecutionContext *context)
+{
+ /*
+ * A scratch context might never be needed in a given plpython procedure,
+ * so allocate it on first request.
+ */
+ if (context->scratch_ctx == NULL)
+ context->scratch_ctx =
+ AllocSetContextCreate(TopTransactionContext,
+ "PL/Python scratch context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+ return context->scratch_ctx;
+}
+
static PLyExecutionContext *
PLy_push_execution_context(void)
{
- PLyExecutionContext *context = PLy_malloc(sizeof(PLyExecutionContext));
+ PLyExecutionContext *context;
+ context = (PLyExecutionContext *)
+ MemoryContextAlloc(TopTransactionContext, sizeof(PLyExecutionContext));
context->curr_proc = NULL;
- context->scratch_ctx = AllocSetContextCreate(TopTransactionContext,
- "PL/Python scratch context",
- ALLOCSET_DEFAULT_MINSIZE,
- ALLOCSET_DEFAULT_INITSIZE,
- ALLOCSET_DEFAULT_MAXSIZE);
+ context->scratch_ctx = NULL;
context->next = PLy_execution_contexts;
PLy_execution_contexts = context;
return context;
PLy_execution_contexts = context->next;
- MemoryContextDelete(context->scratch_ctx);
- PLy_free(context);
+ if (context->scratch_ctx)
+ MemoryContextDelete(context->scratch_ctx);
+ pfree(context);
}
/* Get the current execution context */
extern PLyExecutionContext *PLy_current_execution_context(void);
+/* Get the scratch memory context for specified execution context */
+extern MemoryContext PLy_get_scratch_context(PLyExecutionContext *context);
+
#endif /* PLPY_MAIN_H */
#include "plpy_planobject.h"
#include "plpy_elog.h"
+#include "utils/memutils.h"
static void PLy_plan_dealloc(PyObject *arg);
ob->types = NULL;
ob->values = NULL;
ob->args = NULL;
+ ob->mcxt = NULL;
return (PyObject *) ob;
}
PLyPlanObject *ob = (PLyPlanObject *) arg;
if (ob->plan)
+ {
SPI_freeplan(ob->plan);
- if (ob->types)
- PLy_free(ob->types);
- if (ob->values)
- PLy_free(ob->values);
- if (ob->args)
+ ob->plan = NULL;
+ }
+ if (ob->mcxt)
{
- int i;
-
- for (i = 0; i < ob->nargs; i++)
- PLy_typeinfo_dealloc(&ob->args[i]);
- PLy_free(ob->args);
+ MemoryContextDelete(ob->mcxt);
+ ob->mcxt = NULL;
}
-
arg->ob_type->tp_free(arg);
}
Oid *types;
Datum *values;
PLyTypeInfo *args;
+ MemoryContext mcxt;
} PLyPlanObject;
extern void PLy_plan_init_type(void);
else if (!PLy_procedure_valid(proc, procTup))
{
/* Found it, but it's invalid, free and reuse the cache entry */
- PLy_procedure_delete(proc);
- PLy_free(proc);
+ entry->proc = NULL;
+ if (proc)
+ PLy_procedure_delete(proc);
proc = PLy_procedure_create(procTup, fn_oid, is_trigger);
entry->proc = proc;
}
char procName[NAMEDATALEN + 256];
Form_pg_proc procStruct;
PLyProcedure *volatile proc;
- char *volatile procSource = NULL;
- Datum prosrcdatum;
- bool isnull;
- int i,
- rv;
+ MemoryContext cxt;
+ MemoryContext oldcxt;
+ int rv;
procStruct = (Form_pg_proc) GETSTRUCT(procTup);
rv = snprintf(procName, sizeof(procName),
if (rv >= sizeof(procName) || rv < 0)
elog(ERROR, "procedure name would overrun buffer");
- proc = PLy_malloc(sizeof(PLyProcedure));
- proc->proname = PLy_strdup(NameStr(procStruct->proname));
- proc->pyname = PLy_strdup(procName);
- proc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
- proc->fn_tid = procTup->t_self;
- /* Remember if function is STABLE/IMMUTABLE */
- proc->fn_readonly =
- (procStruct->provolatile != PROVOLATILE_VOLATILE);
- PLy_typeinfo_init(&proc->result);
- for (i = 0; i < FUNC_MAX_ARGS; i++)
- PLy_typeinfo_init(&proc->args[i]);
- proc->nargs = 0;
- proc->langid = procStruct->prolang;
- {
- MemoryContext oldcxt;
+ cxt = AllocSetContextCreate(TopMemoryContext,
+ procName,
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
- Datum protrftypes_datum = SysCacheGetAttr(PROCOID, procTup,
- Anum_pg_proc_protrftypes, &isnull);
+ oldcxt = MemoryContextSwitchTo(cxt);
- oldcxt = MemoryContextSwitchTo(TopMemoryContext);
- proc->trftypes = isnull ? NIL : oid_array_to_list(protrftypes_datum);
- MemoryContextSwitchTo(oldcxt);
- }
- proc->code = proc->statics = NULL;
- proc->globals = NULL;
- proc->is_setof = procStruct->proretset;
- proc->setof = NULL;
- proc->src = NULL;
- proc->argnames = NULL;
+ proc = (PLyProcedure *) palloc0(sizeof(PLyProcedure));
+ proc->mcxt = cxt;
PG_TRY();
{
+ Datum protrftypes_datum;
+ Datum prosrcdatum;
+ bool isnull;
+ char *procSource;
+ int i;
+
+ proc->proname = pstrdup(NameStr(procStruct->proname));
+ proc->pyname = pstrdup(procName);
+ proc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
+ proc->fn_tid = procTup->t_self;
+ /* Remember if function is STABLE/IMMUTABLE */
+ proc->fn_readonly =
+ (procStruct->provolatile != PROVOLATILE_VOLATILE);
+ PLy_typeinfo_init(&proc->result, proc->mcxt);
+ for (i = 0; i < FUNC_MAX_ARGS; i++)
+ PLy_typeinfo_init(&proc->args[i], proc->mcxt);
+ proc->nargs = 0;
+ proc->langid = procStruct->prolang;
+ protrftypes_datum = SysCacheGetAttr(PROCOID, procTup,
+ Anum_pg_proc_protrftypes,
+ &isnull);
+ proc->trftypes = isnull ? NIL : oid_array_to_list(protrftypes_datum);
+ proc->code = proc->statics = NULL;
+ proc->globals = NULL;
+ proc->is_setof = procStruct->proretset;
+ proc->setof = NULL;
+ proc->src = NULL;
+ proc->argnames = NULL;
+
/*
* get information required for output conversion of the return value,
* but only if this isn't a trigger.
Oid *types;
char **names,
*modes;
- int i,
- pos,
+ int pos,
total;
/* extract argument type info from the pg_proc tuple */
}
}
- proc->argnames = (char **) PLy_malloc0(sizeof(char *) * proc->nargs);
+ proc->argnames = (char **) palloc0(sizeof(char *) * proc->nargs);
for (i = pos = 0; i < total; i++)
{
HeapTuple argTypeTup;
}
/* get argument name */
- proc->argnames[pos] = names ? PLy_strdup(names[i]) : NULL;
+ proc->argnames[pos] = names ? pstrdup(names[i]) : NULL;
ReleaseSysCache(argTypeTup);
PLy_procedure_compile(proc, procSource);
pfree(procSource);
- procSource = NULL;
}
PG_CATCH();
{
+ MemoryContextSwitchTo(oldcxt);
PLy_procedure_delete(proc);
- if (procSource)
- pfree(procSource);
-
PG_RE_THROW();
}
PG_END_TRY();
+ MemoryContextSwitchTo(oldcxt);
return proc;
}
*/
msrc = PLy_procedure_munge_source(proc->pyname, src);
/* Save the mangled source for later inclusion in tracebacks */
- proc->src = PLy_strdup(msrc);
+ proc->src = MemoryContextStrdup(proc->mcxt, msrc);
crv = PyRun_String(msrc, Py_file_input, proc->globals, NULL);
pfree(msrc);
void
PLy_procedure_delete(PLyProcedure *proc)
{
- int i;
-
Py_XDECREF(proc->code);
Py_XDECREF(proc->statics);
Py_XDECREF(proc->globals);
- if (proc->proname)
- PLy_free(proc->proname);
- if (proc->pyname)
- PLy_free(proc->pyname);
- for (i = 0; i < proc->nargs; i++)
- {
- if (proc->args[i].is_rowtype == 1)
- {
- if (proc->args[i].in.r.atts)
- PLy_free(proc->args[i].in.r.atts);
- if (proc->args[i].out.r.atts)
- PLy_free(proc->args[i].out.r.atts);
- }
- if (proc->argnames && proc->argnames[i])
- PLy_free(proc->argnames[i]);
- }
- if (proc->src)
- PLy_free(proc->src);
- if (proc->argnames)
- PLy_free(proc->argnames);
+ MemoryContextDelete(proc->mcxt);
}
/*
int i;
bool valid;
- Assert(proc != NULL);
+ if (proc == NULL)
+ return false;
/* If the pg_proc tuple has changed, it's not valid */
if (!(proc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
/* cached procedure data */
typedef struct PLyProcedure
{
+ MemoryContext mcxt; /* context holding this PLyProcedure and its
+ * subsidiary data */
char *proname; /* SQL name of procedure */
char *pyname; /* Python name of procedure */
TransactionId fn_xmin;
if ((plan = (PLyPlanObject *) PLy_plan_new()) == NULL)
return NULL;
+ plan->mcxt = AllocSetContextCreate(TopMemoryContext,
+ "PL/Python plan context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+ oldcontext = MemoryContextSwitchTo(plan->mcxt);
+
nargs = list ? PySequence_Length(list) : 0;
plan->nargs = nargs;
- plan->types = nargs ? PLy_malloc(sizeof(Oid) * nargs) : NULL;
- plan->values = nargs ? PLy_malloc(sizeof(Datum) * nargs) : NULL;
- plan->args = nargs ? PLy_malloc(sizeof(PLyTypeInfo) * nargs) : NULL;
+ plan->types = nargs ? palloc(sizeof(Oid) * nargs) : NULL;
+ plan->values = nargs ? palloc(sizeof(Datum) * nargs) : NULL;
+ plan->args = nargs ? palloc(sizeof(PLyTypeInfo) * nargs) : NULL;
+
+ MemoryContextSwitchTo(oldcontext);
oldcontext = CurrentMemoryContext;
oldowner = CurrentResourceOwner;
*/
for (i = 0; i < nargs; i++)
{
- PLy_typeinfo_init(&plan->args[i]);
+ PLy_typeinfo_init(&plan->args[i], plan->mcxt);
plan->values[i] = PointerGetDatum(NULL);
}
{
PLyTypeInfo args;
int i;
+ MemoryContext cxt;
Py_DECREF(result->nrows);
result->nrows = PyInt_FromLong(rows);
- PLy_typeinfo_init(&args);
+
+ cxt = AllocSetContextCreate(CurrentMemoryContext,
+ "PL/Python temp context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+ PLy_typeinfo_init(&args, cxt);
oldcontext = CurrentMemoryContext;
PG_TRY();
PG_CATCH();
{
MemoryContextSwitchTo(oldcontext);
- PLy_typeinfo_dealloc(&args);
+ MemoryContextDelete(cxt);
Py_DECREF(result);
PG_RE_THROW();
}
PG_END_TRY();
- PLy_typeinfo_dealloc(&args);
+ MemoryContextDelete(cxt);
SPI_freetuptable(tuptable);
}
#include "access/xact.h"
#include "executor/spi.h"
+#include "utils/memutils.h"
#include "plpython.h"
subxact->started = true;
oldcontext = CurrentMemoryContext;
- subxactdata = PLy_malloc(sizeof(*subxactdata));
+ subxactdata = (PLySubtransactionData *)
+ MemoryContextAlloc(TopTransactionContext,
+ sizeof(PLySubtransactionData));
+
subxactdata->oldcontext = oldcontext;
subxactdata->oldowner = CurrentResourceOwner;
BeginInternalSubTransaction(NULL);
- /* Do not want to leave the previous memory context */
- MemoryContextSwitchTo(oldcontext);
+ /* Be sure that cells of explicit_subtransactions list are long-lived */
+ MemoryContextSwitchTo(TopTransactionContext);
explicit_subtransactions = lcons(subxactdata, explicit_subtransactions);
+ /* Caller wants to stay in original memory context */
+ MemoryContextSwitchTo(oldcontext);
+
Py_INCREF(self);
return self;
}
MemoryContextSwitchTo(subxactdata->oldcontext);
CurrentResourceOwner = subxactdata->oldowner;
- PLy_free(subxactdata);
+ pfree(subxactdata);
/*
* AtEOSubXact_SPI() should not have popped any SPI context, but just in
/* I/O function caching */
-static void PLy_input_datum_func2(PLyDatumToOb *arg, Oid typeOid, HeapTuple typeTup, Oid langid, List *trftypes);
-static void PLy_output_datum_func2(PLyObToDatum *arg, HeapTuple typeTup, Oid langid, List *trftypes);
+static void PLy_input_datum_func2(PLyDatumToOb *arg, MemoryContext arg_mcxt, Oid typeOid, HeapTuple typeTup, Oid langid, List *trftypes);
+static void PLy_output_datum_func2(PLyObToDatum *arg, MemoryContext arg_mcxt, HeapTuple typeTup, Oid langid, List *trftypes);
/* conversion from Datums to Python objects */
static PyObject *PLyBool_FromBool(PLyDatumToOb *arg, Datum d);
static Datum PLySequence_ToComposite(PLyTypeInfo *info, TupleDesc desc, PyObject *sequence);
static Datum PLyGenericObject_ToComposite(PLyTypeInfo *info, TupleDesc desc, PyObject *object);
-/* make allocations in the TopMemoryContext */
-static void perm_fmgr_info(Oid functionId, FmgrInfo *finfo);
-
void
-PLy_typeinfo_init(PLyTypeInfo *arg)
+PLy_typeinfo_init(PLyTypeInfo *arg, MemoryContext mcxt)
{
arg->is_rowtype = -1;
arg->in.r.natts = arg->out.r.natts = 0;
arg->typ_relid = InvalidOid;
arg->typrel_xmin = InvalidTransactionId;
ItemPointerSetInvalid(&arg->typrel_tid);
-}
-
-void
-PLy_typeinfo_dealloc(PLyTypeInfo *arg)
-{
- if (arg->is_rowtype == 1)
- {
- int i;
-
- for (i = 0; i < arg->in.r.natts; i++)
- {
- if (arg->in.r.atts[i].elm != NULL)
- PLy_free(arg->in.r.atts[i].elm);
- }
- if (arg->in.r.atts)
- PLy_free(arg->in.r.atts);
- for (i = 0; i < arg->out.r.natts; i++)
- {
- if (arg->out.r.atts[i].elm != NULL)
- PLy_free(arg->out.r.atts[i].elm);
- }
- if (arg->out.r.atts)
- PLy_free(arg->out.r.atts);
- }
+ arg->mcxt = mcxt;
}
/*
if (arg->is_rowtype > 0)
elog(ERROR, "PLyTypeInfo struct is initialized for Tuple");
arg->is_rowtype = 0;
- PLy_input_datum_func2(&(arg->in.d), typeOid, typeTup, langid, trftypes);
+ PLy_input_datum_func2(&(arg->in.d), arg->mcxt, typeOid, typeTup, langid, trftypes);
}
void
if (arg->is_rowtype > 0)
elog(ERROR, "PLyTypeInfo struct is initialized for a Tuple");
arg->is_rowtype = 0;
- PLy_output_datum_func2(&(arg->out.d), typeTup, langid, trftypes);
+ PLy_output_datum_func2(&(arg->out.d), arg->mcxt, typeTup, langid, trftypes);
}
void
{
int i;
PLyExecutionContext *exec_ctx = PLy_current_execution_context();
+ MemoryContext oldcxt;
+
+ oldcxt = MemoryContextSwitchTo(arg->mcxt);
if (arg->is_rowtype == 0)
elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
if (arg->in.r.natts != desc->natts)
{
if (arg->in.r.atts)
- PLy_free(arg->in.r.atts);
+ pfree(arg->in.r.atts);
arg->in.r.natts = desc->natts;
- arg->in.r.atts = PLy_malloc0(desc->natts * sizeof(PLyDatumToOb));
+ arg->in.r.atts = palloc0(desc->natts * sizeof(PLyDatumToOb));
}
/* Can this be an unnamed tuple? If not, then an Assert would be enough */
elog(ERROR, "cache lookup failed for type %u",
desc->attrs[i]->atttypid);
- PLy_input_datum_func2(&(arg->in.r.atts[i]),
+ PLy_input_datum_func2(&(arg->in.r.atts[i]), arg->mcxt,
desc->attrs[i]->atttypid,
typeTup,
exec_ctx->curr_proc->langid,
ReleaseSysCache(typeTup);
}
+
+ MemoryContextSwitchTo(oldcxt);
}
void
{
int i;
PLyExecutionContext *exec_ctx = PLy_current_execution_context();
+ MemoryContext oldcxt;
+
+ oldcxt = MemoryContextSwitchTo(arg->mcxt);
if (arg->is_rowtype == 0)
elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
if (arg->out.r.natts != desc->natts)
{
if (arg->out.r.atts)
- PLy_free(arg->out.r.atts);
+ pfree(arg->out.r.atts);
arg->out.r.natts = desc->natts;
- arg->out.r.atts = PLy_malloc0(desc->natts * sizeof(PLyObToDatum));
+ arg->out.r.atts = palloc0(desc->natts * sizeof(PLyObToDatum));
}
Assert(OidIsValid(desc->tdtypeid));
elog(ERROR, "cache lookup failed for type %u",
desc->attrs[i]->atttypid);
- PLy_output_datum_func2(&(arg->out.r.atts[i]), typeTup,
+ PLy_output_datum_func2(&(arg->out.r.atts[i]), arg->mcxt, typeTup,
exec_ctx->curr_proc->langid,
exec_ctx->curr_proc->trftypes);
ReleaseSysCache(typeTup);
}
+
+ MemoryContextSwitchTo(oldcxt);
}
void
{
PyObject *volatile dict;
PLyExecutionContext *exec_ctx = PLy_current_execution_context();
+ MemoryContext scratch_context = PLy_get_scratch_context(exec_ctx);
MemoryContext oldcontext = CurrentMemoryContext;
- int i;
if (info->is_rowtype != 1)
elog(ERROR, "PLyTypeInfo structure describes a datum");
PG_TRY();
{
+ int i;
+
/*
* Do the work in the scratch context to avoid leaking memory from the
* datatype output function calls.
*/
- MemoryContextSwitchTo(exec_ctx->scratch_ctx);
+ MemoryContextSwitchTo(scratch_context);
for (i = 0; i < info->in.r.natts; i++)
{
char *key;
}
}
MemoryContextSwitchTo(oldcontext);
- MemoryContextReset(exec_ctx->scratch_ctx);
+ MemoryContextReset(scratch_context);
}
PG_CATCH();
{
}
static void
-PLy_output_datum_func2(PLyObToDatum *arg, HeapTuple typeTup, Oid langid, List *trftypes)
+PLy_output_datum_func2(PLyObToDatum *arg, MemoryContext arg_mcxt, HeapTuple typeTup, Oid langid, List *trftypes)
{
Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
Oid element_type;
Oid base_type;
Oid funcid;
+ MemoryContext oldcxt;
- perm_fmgr_info(typeStruct->typinput, &arg->typfunc);
+ oldcxt = MemoryContextSwitchTo(arg_mcxt);
+
+ fmgr_info_cxt(typeStruct->typinput, &arg->typfunc, arg_mcxt);
arg->typoid = HeapTupleGetOid(typeTup);
arg->typmod = -1;
arg->typioparam = getTypeIOParam(typeTup);
if ((funcid = get_transform_tosql(base_type, langid, trftypes)))
{
arg->func = PLyObject_ToTransform;
- perm_fmgr_info(funcid, &arg->typtransform);
+ fmgr_info_cxt(funcid, &arg->typtransform, arg_mcxt);
}
else if (typeStruct->typtype == TYPTYPE_COMPOSITE)
{
if (type_is_rowtype(element_type))
arg->func = PLyObject_ToComposite;
- arg->elm = PLy_malloc0(sizeof(*arg->elm));
+ arg->elm = palloc0(sizeof(*arg->elm));
arg->elm->func = arg->func;
arg->elm->typtransform = arg->typtransform;
arg->func = PLySequence_ToArray;
get_type_io_data(element_type, IOFunc_input,
&arg->elm->typlen, &arg->elm->typbyval, &arg->elm->typalign, &dummy_delim,
&arg->elm->typioparam, &funcid);
- perm_fmgr_info(funcid, &arg->elm->typfunc);
+ fmgr_info_cxt(funcid, &arg->elm->typfunc, arg_mcxt);
}
+
+ MemoryContextSwitchTo(oldcxt);
}
static void
-PLy_input_datum_func2(PLyDatumToOb *arg, Oid typeOid, HeapTuple typeTup, Oid langid, List *trftypes)
+PLy_input_datum_func2(PLyDatumToOb *arg, MemoryContext arg_mcxt, Oid typeOid, HeapTuple typeTup, Oid langid, List *trftypes)
{
Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
Oid element_type;
Oid base_type;
Oid funcid;
+ MemoryContext oldcxt;
+
+ oldcxt = MemoryContextSwitchTo(arg_mcxt);
/* Get the type's conversion information */
- perm_fmgr_info(typeStruct->typoutput, &arg->typfunc);
+ fmgr_info_cxt(typeStruct->typoutput, &arg->typfunc, arg_mcxt);
arg->typoid = HeapTupleGetOid(typeTup);
arg->typmod = -1;
arg->typioparam = getTypeIOParam(typeTup);
if ((funcid = get_transform_fromsql(base_type, langid, trftypes)))
{
arg->func = PLyObject_FromTransform;
- perm_fmgr_info(funcid, &arg->typtransform);
+ fmgr_info_cxt(funcid, &arg->typtransform, arg_mcxt);
}
else
switch (base_type)
char dummy_delim;
Oid funcid;
- arg->elm = PLy_malloc0(sizeof(*arg->elm));
+ arg->elm = palloc0(sizeof(*arg->elm));
arg->elm->func = arg->func;
arg->elm->typtransform = arg->typtransform;
arg->func = PLyList_FromArray;
get_type_io_data(element_type, IOFunc_output,
&arg->elm->typlen, &arg->elm->typbyval, &arg->elm->typalign, &dummy_delim,
&arg->elm->typioparam, &funcid);
- perm_fmgr_info(funcid, &arg->elm->typfunc);
+ fmgr_info_cxt(funcid, &arg->elm->typfunc, arg_mcxt);
}
+
+ MemoryContextSwitchTo(oldcxt);
}
static PyObject *
Datum rv;
PLyTypeInfo info;
TupleDesc desc;
+ MemoryContext cxt;
if (typmod != -1)
elog(ERROR, "received unnamed record type as input");
/* Create a dummy PLyTypeInfo */
+ cxt = AllocSetContextCreate(CurrentMemoryContext,
+ "PL/Python temp context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
MemSet(&info, 0, sizeof(PLyTypeInfo));
- PLy_typeinfo_init(&info);
+ PLy_typeinfo_init(&info, cxt);
/* Mark it as needing output routines lookup */
info.is_rowtype = 2;
ReleaseTupleDesc(desc);
- PLy_typeinfo_dealloc(&info);
+ MemoryContextDelete(cxt);
return rv;
}
HeapTuple typeTup;
PLyTypeInfo locinfo;
PLyExecutionContext *exec_ctx = PLy_current_execution_context();
+ MemoryContext cxt;
/* Create a dummy PLyTypeInfo */
+ cxt = AllocSetContextCreate(CurrentMemoryContext,
+ "PL/Python temp context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
MemSet(&locinfo, 0, sizeof(PLyTypeInfo));
- PLy_typeinfo_init(&locinfo);
+ PLy_typeinfo_init(&locinfo, cxt);
typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(desc->tdtypeid));
if (!HeapTupleIsValid(typeTup))
elog(ERROR, "cache lookup failed for type %u", desc->tdtypeid);
- PLy_output_datum_func2(&locinfo.out.d, typeTup,
+ PLy_output_datum_func2(&locinfo.out.d, locinfo.mcxt, typeTup,
exec_ctx->curr_proc->langid,
exec_ctx->curr_proc->trftypes);
result = PLyObject_ToDatum(&locinfo.out.d, desc->tdtypmod, string);
- PLy_typeinfo_dealloc(&locinfo);
+ MemoryContextDelete(cxt);
return result;
}
return result;
}
-
-/*
- * This routine is a crock, and so is everyplace that calls it. The problem
- * is that the cached form of plpython functions/queries is allocated permanently
- * (mostly via malloc()) and never released until backend exit. Subsidiary
- * data structures such as fmgr info records therefore must live forever
- * as well. A better implementation would store all this stuff in a per-
- * function memory context that could be reclaimed at need. In the meantime,
- * fmgr_info_cxt must be called specifying TopMemoryContext so that whatever
- * it might allocate, and whatever the eventual function might allocate using
- * fn_mcxt, will live forever too.
- */
-static void
-perm_fmgr_info(Oid functionId, FmgrInfo *finfo)
-{
- fmgr_info_cxt(functionId, finfo, TopMemoryContext);
-}
Oid typ_relid;
TransactionId typrel_xmin;
ItemPointerData typrel_tid;
+
+ /* context for subsidiary data (doesn't belong to this struct though) */
+ MemoryContext mcxt;
} PLyTypeInfo;
-extern void PLy_typeinfo_init(PLyTypeInfo *arg);
-extern void PLy_typeinfo_dealloc(PLyTypeInfo *arg);
+extern void PLy_typeinfo_init(PLyTypeInfo *arg, MemoryContext mcxt);
extern void PLy_input_datum_func(PLyTypeInfo *arg, Oid typeOid, HeapTuple typeTup, Oid langid, List *trftypes);
extern void PLy_output_datum_func(PLyTypeInfo *arg, HeapTuple typeTup, Oid langid, List *trftypes);
#include "plpy_elog.h"
-void *
-PLy_malloc(size_t bytes)
-{
- /* We need our allocations to be long-lived, so use TopMemoryContext */
- return MemoryContextAlloc(TopMemoryContext, bytes);
-}
-
-void *
-PLy_malloc0(size_t bytes)
-{
- void *ptr = PLy_malloc(bytes);
-
- MemSet(ptr, 0, bytes);
- return ptr;
-}
-
-char *
-PLy_strdup(const char *str)
-{
- char *result;
- size_t len;
-
- len = strlen(str) + 1;
- result = PLy_malloc(len);
- memcpy(result, str, len);
-
- return result;
-}
-
-/* define this away */
-void
-PLy_free(void *ptr)
-{
- pfree(ptr);
-}
-
/*
* Convert a Python unicode object to a Python string/bytes object in
* PostgreSQL server encoding. Reference ownership is passed to the
#ifndef PLPY_UTIL_H
#define PLPY_UTIL_H
-extern void *PLy_malloc(size_t bytes);
-extern void *PLy_malloc0(size_t bytes);
-extern char *PLy_strdup(const char *str);
-extern void PLy_free(void *ptr);
-
extern PyObject *PLyUnicode_Bytes(PyObject *unicode);
extern char *PLyUnicode_AsString(PyObject *unicode);
projects / postgresql / commitdiff