static PyObj
void_new(PyTypeObject *subtype, PyObj args, PyObj kw)
{
static char *kwlist[] = {NULL};
PyObj ob;
Assert(subtype != NULL);
if (!PyArg_ParseTupleAndKeywords(args, kw, "O", kwlist, &ob))
return(NULL);
Assert(ob != NULL);
if (Py_TYPE(ob) == subtype)
{
Py_INCREF(ob);
return(ob);
}
if (ob != Py_None)
{
PyErr_Format(PyExc_ValueError, "pseudo type '%s' requires None",
subtype->tp_name);
return(NULL);
}
if (PyPg_void_object == NULL)
{
PyPg_void_object = PyPgObject_New(subtype, 0);
}
Py_XINCREF(PyPg_void_object);
return(PyPg_void_object);
}
PyObj
PyPgObject_FromTypeOidAndDatum(Oid typeoid, Datum d)
{
PyObj typ, rob;
typ = PyPgType_FromOid(typeoid);
if (typ == NULL)
return(NULL);
rob = PyPgObject_New(typ, d);
Py_DECREF(typ);
return(rob);
}
static PyObj
array_slice(PyObj self, Py_ssize_t from, Py_ssize_t to)
{
PyObj elm;
PyPgTypeInfo etc;
ArrayType *at, *rat = NULL;
PyObj rob = NULL;
int idx_lower[MAXDIM] = {(int) from+1, 0,};
int idx_upper[MAXDIM] = {(int) to+1, 0,};
elm = PyPgType_GetElementType(Py_TYPE(self));
Assert(elm != NULL);
etc = PyPgTypeInfo(elm);
Assert(etc != NULL);
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
Assert(at != NULL);
PG_TRY();
{
rat = array_get_slice(at, 1, idx_upper, idx_lower,
PyPgTypeInfo(Py_TYPE(self))->typlen,
etc->typlen, etc->typbyval, etc->typalign);
rob = PyPgObject_New(Py_TYPE(self), PointerGetDatum(rat));
if (rob == NULL)
pfree(rat);
}
PG_CATCH();
{
PyErr_SetPgError(false);
return(NULL);
}
PG_END_TRY();
return(rob);
}
static PyObj
obj_new(PyTypeObject *subtype, PyObj args, PyObj kw)
{
static char *words[] = {"source", "mod", NULL};
PyObj src = NULL, mod = NULL, rob = NULL, typmodin_ob = NULL;
Datum d;
bool isnull = true;
int32 typmod = -1;
if (DB_IS_NOT_READY())
return(NULL);
/*
* The type *must* be a PyPgType instance.
* Use CheckExact for speed.
* Subclassing PyPgType_Type is not supported.
*/
if (PyPgObjectType_Require(subtype))
return(NULL);
/*
* Grab a single "source" argument and an
* optional "mod" from the args and kw.
*/
if (!PyArg_ParseTupleAndKeywords(args, kw, "O|O", words, &src, &mod))
return(NULL);
if (mod != NULL && mod != Py_None)
{
PyObj lo;
if (!PyList_CheckExact(mod))
{
lo = Py_Call((PyObj) &PyList_Type, mod);
if (lo == NULL)
{
PyErr_SetString(PyExc_ValueError, "'mod' keyword must be a sequence");
return(NULL);
}
}
else
{
Py_INCREF(mod);
lo = mod;
}
typmodin_ob = Py_Call(PyPg_cstring_Array_Type, lo);
Py_DECREF(lo);
if (typmodin_ob == NULL)
{
PyErr_SetString(PyExc_ValueError, "invalid typmod object");
return(NULL);
}
}
else if (Py_TYPE(src) == subtype)
{
/*
* Exact type and no typmod.
*/
rob = src;
Py_INCREF(rob);
return(rob);
}
PG_TRY();
{
if (typmodin_ob != NULL)
{
typmod = PyPgType_modin((PyObj) subtype, typmodin_ob);
}
if (src == Py_None)
{
d = 0;
isnull = true;
}
else
{
PyPgType_DatumNew((PyObj) subtype, src, typmod, &d, &isnull);
}
if (isnull)
{
rob = Py_None;
Py_INCREF(rob);
}
else
{
rob = PyPgObject_New(subtype, d);
if (PyPgType_ShouldFree(subtype))
{
Datum fd = d;
d = 0;
isnull = true;
/*
* If it fails to pfree, don't try it again in
* the catch.
*/
pfree(DatumGetPointer(fd));
}
}
}
PG_CATCH();
{
Py_XDECREF(rob);
rob = NULL;
if (!isnull && PyPgType_ShouldFree(subtype))
pfree(DatumGetPointer(d));
PyErr_SetPgError(false);
}
PG_END_TRY();
Py_XDECREF(typmodin_ob);
return(rob);
}
/*
* Python only supports prefix unary operators.
*/
static PyObj
unary_operate(const char *op, PyObj right)
{
PyObj rob = NULL;
Datum dright = PyPgObject_GetDatum(right);
Oid right_oid = PyPgType_GetOid(Py_TYPE(right));
Py_ALLOCATE_OWNER();
{
PyObj rtype;
Operator opt;
volatile Datum rd = 0;
List * volatile namelist = NULL;
PG_TRY();
{
struct FmgrInfo flinfo = {0,};
struct FunctionCallInfoData fcinfo = {0,};
Form_pg_operator ops;
Oid declared, result_type, fn_oid;
namelist = stringToQualifiedNameList(op);
opt = oper(NULL, (List *) namelist, InvalidOid, right_oid, false, 1);
ops = (Form_pg_operator) GETSTRUCT(opt);
fn_oid = ops->oprcode;
declared = ops->oprright;
result_type = ops->oprresult;
ReleaseSysCache((HeapTuple) opt);
result_type = enforce_generic_type_consistency(
&right_oid, &declared, 1, result_type, true);
rtype = PyPgType_FromOid(result_type);
Py_XACQUIRE(rtype);
list_free((List *) namelist);
namelist = NULL;
if (rtype == NULL)
elog(ERROR, "operator result type could not be created");
fmgr_info(fn_oid, &flinfo);
fcinfo.flinfo = &flinfo;
fcinfo.nargs = 1;
fcinfo.arg[0] = dright;
fcinfo.argnull[0] = false;
rd = FunctionCallInvoke(&fcinfo);
if (fcinfo.isnull)
{
rob = Py_None;
Py_INCREF(rob);
Py_ACQUIRE(rob);
}
else
{
rob = PyPgObject_New(rtype, rd);
Py_XACQUIRE(rob);
if (PyPgType_ShouldFree(rtype))
pfree(DatumGetPointer(rd));
}
}
PG_CATCH();
{
PyErr_SetPgError(false);
rob = NULL;
}
PG_END_TRY();
Py_XINCREF(rob);
}
Py_DEALLOCATE_OWNER();
return(rob);
}
static PyObj
binary_operate(const char *op, PyObj left, PyObj right)
{
PyObj base = PyPgObject_Check(left) ? left : right;
PyObj rob = NULL;
Datum dleft, dright;
Datum dcoerce;
bool lisnull = false, risnull = false, coerce_isnull = true;
Oid left_oid, right_oid;
Py_ALLOCATE_OWNER();
{
volatile Datum rd = 0;
List * volatile namelist = NULL;
PyObj rtype;
PyObj coerce = NULL;
PG_TRY();
{
struct FmgrInfo flinfo = {0,};
struct FunctionCallInfoData fcinfo = {0,};
Operator opt;
Form_pg_operator ops;
Oid actual[2];
Oid declared[2];
Oid result_type, fn_oid;
/*
* base and coerce are used to manage preliminary coercion.
* If either side of the operator is not a PyPgObject, convert the
* object to the type of the other side.
*/
if (base == left)
{
if (!PyPgObject_Check(right))
coerce = right;
}
else
coerce = left;
if (coerce != NULL)
{
PyPgType_DatumNew((PyObj) Py_TYPE(base),
coerce, -1, &dcoerce, &coerce_isnull);
if (base == left)
{
dleft = PyPgObject_GetDatum(left);
lisnull = false;
dright = dcoerce;
risnull = coerce_isnull;
}
else
{
dleft = dcoerce;
lisnull = coerce_isnull;
dright = PyPgObject_GetDatum(right);
risnull = false;
}
/*
* Both are the same type as base due to coercion.
*/
left_oid = right_oid = PyPgType_GetOid(Py_TYPE(base));
}
else
{
/*
* Both objects are PyPgObjects.
*/
dleft = PyPgObject_GetDatum(left);
left_oid = PyPgType_GetOid(Py_TYPE(left));
dright = PyPgObject_GetDatum(right);
right_oid = PyPgType_GetOid(Py_TYPE(right));
}
namelist = stringToQualifiedNameList(op);
opt = oper(NULL, (List *) namelist, left_oid, right_oid, false, 1);
ops = (Form_pg_operator) GETSTRUCT(opt);
fn_oid = ops->oprcode;
declared[0] = ops->oprleft;
declared[1] = ops->oprright;
actual[0] = left_oid;
actual[1] = right_oid;
result_type = ops->oprresult;
ReleaseSysCache((HeapTuple) opt);
result_type = enforce_generic_type_consistency(
actual, declared, 2, result_type, true);
rtype = PyPgType_FromOid(result_type);
rtype = Py_XACQUIRE(rtype);
list_free((List *) namelist);
namelist = NULL;
if (rtype == NULL)
PyErr_RelayException();
fmgr_info(fn_oid, &flinfo);
fcinfo.flinfo = &flinfo;
fcinfo.nargs = 2;
fcinfo.arg[0] = dleft;
fcinfo.argnull[0] = lisnull;
fcinfo.arg[1] = dright;
fcinfo.argnull[1] = risnull;
rd = FunctionCallInvoke(&fcinfo);
if (fcinfo.isnull)
rob = Py_None;
else
{
rob = PyPgObject_New(rtype, rd);
Py_XACQUIRE(rob);
if (PyPgType_ShouldFree(rtype))
pfree(DatumGetPointer(rd));
}
if (!coerce_isnull && PyPgType_ShouldFree(Py_TYPE(base)))
pfree(DatumGetPointer(dcoerce));
}
PG_CATCH();
{
PyErr_SetPgError(false);
rob = NULL;
}
PG_END_TRY();
Py_XINCREF(rob);
}
Py_DEALLOCATE_OWNER();
return(rob);
}
/*
* Array.get_element(indexes) - Get an element from the array.
*
* This uses Python sequence semantics(zero-based indexes, IndexError's).
*/
static PyObj
array_get_element(PyObj self, PyObj indexes_ob)
{
PyObj tup, element_type, rob = NULL;
PyPgTypeInfo atypinfo, typinfo;
ArrayType *at;
int i, nindexes, indexes[MAXDIM] = {0,};
/*
* Convert the indexes_ob into a tuple and extract the values
* into the indexes[] array. Do any necessary checks along the way.
*/
tup = Py_Call((PyObj) &PyTuple_Type, indexes_ob);
if (tup == NULL)
return(NULL);
nindexes = (int) PyTuple_GET_SIZE(tup);
if (!(nindexes > 0))
{
Py_DECREF(tup);
PyErr_SetString(PyExc_ValueError, "empty index tuple");
return(NULL);
}
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
Assert(at != NULL);
if (nindexes != ARR_NDIM(at))
{
Py_DECREF(tup);
if (ARR_NDIM(at) == 0)
PyErr_SetString(PyExc_IndexError, "no elements in array");
else
PyErr_Format(PyExc_ValueError, "element access requires exactly %d indexes, given %d",
ARR_NDIM(at), nindexes);
return(NULL);
}
for (i = 0; i < nindexes; ++i)
{
int index;
index = (int) PyNumber_AsSsize_t(PyTuple_GET_ITEM(tup, i),
NULL);
if (PyErr_Occurred())
{
Py_DECREF(tup);
return(NULL);
}
/*
* Adjust for backwards based access. (feature of get_element)
*/
if (index < 0)
indexes[i] = index + ARR_DIMS(at)[i];
else
indexes[i] = index;
if (indexes[i] >= ARR_DIMS(at)[i] || indexes[i] < 0)
{
PyErr_Format(PyExc_IndexError, "index %d out of range %d for axis %d",
index, ARR_DIMS(at)[0], i);
Py_DECREF(tup);
return(NULL);
}
/*
* Adjust by the lowerbounds..
*/
indexes[i] = indexes[i] + ARR_LBOUND(at)[i];
}
Py_DECREF(tup);
atypinfo = PyPgTypeInfo(Py_TYPE(self));
element_type = PyPgType_GetElementType(Py_TYPE(self));
typinfo = PyPgTypeInfo(element_type);
PG_TRY();
{
Datum rd;
bool isnull = false;
rd = array_ref(at, nindexes, indexes, atypinfo->typlen,
typinfo->typlen, typinfo->typbyval, typinfo->typalign, &isnull);
if (isnull)
{
rob = Py_None;
Py_INCREF(rob);
}
else
{
/*
* It points into the array structure, so there's no need to free.
*/
rob = PyPgObject_New(element_type, rd);
}
}
PG_CATCH();
{
PyErr_SetPgError(false);
}
PG_END_TRY();
return(rob);
}
static PyObj
array_item(PyObj self, Py_ssize_t item)
{
volatile PyObj rob = NULL;
PyPgTypeInfo typinfo, atypinfo;
ArrayType *at;
Datum rd;
bool isnull = false;
int index = (int) item;
PyObj elm;
elm = PyPgType_GetElementType(Py_TYPE(self));
typinfo = PyPgTypeInfo(elm);
atypinfo = PyPgTypeInfo(Py_TYPE(self));
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
/* convert index */
++index;
if (ARR_NDIM(at) == 0)
{
PyErr_SetString(PyExc_IndexError, "empty array");
return(NULL);
}
/*
* Note that the comparison is '>', not '>='.
*/
if (index > ARR_DIMS(at)[0])
{
PyErr_Format(PyExc_IndexError, "index %d out of range %d",
item, ARR_DIMS(at)[0]);
return(NULL);
}
/*
* Single dimenion array? Get an element.
*/
if (ARR_NDIM(at) == 1)
{
PG_TRY();
{
rd = array_ref(at, 1, &index, atypinfo->typlen,
typinfo->typlen, typinfo->typbyval, typinfo->typalign, &isnull);
if (isnull)
{
rob = Py_None;
Py_INCREF(rob);
}
else
{
/*
* It points into the array structure, so there's no need to free.
*/
rob = PyPgObject_New(elm, rd);
}
}
PG_CATCH();
{
Py_XDECREF(rob);
rob = NULL;
PyErr_SetPgError(false);
return(NULL);
}
PG_END_TRY();
}
else
{
ArrayType *rat;
int lower[MAXDIM] = {index,0,};
int upper[MAXDIM] = {index,0,};
/*
* Multiple dimensions, so get a slice.
*/
PG_TRY();
{
ArrayType *xat;
Datum *elements;
bool *nulls;
int nelems;
int ndims, i;
int lbs[MAXDIM];
int dims[MAXDIM];
xat = array_get_slice(at, 1, upper, lower, atypinfo->typlen,
typinfo->typlen, typinfo->typbyval, typinfo->typalign);
/*
* Eventually, this should probably be changed to change the already
* allocated ArrayType at 'xat', but for now use the available
* interfaces for creating the expected result.
*/
deconstruct_array(xat,
typinfo->typoid, typinfo->typlen, typinfo->typbyval, typinfo->typalign,
&elements, &nulls, &nelems
);
/*
* Alter dims, lbs, and ndims: we are removing the first dimension.
*/
ndims = ARR_NDIM(xat);
for (i = 1; i < ndims; ++i)
lbs[i-1] = ARR_LBOUND(xat)[i];
for (i = 1; i < ndims; ++i)
dims[i-1] = ARR_DIMS(xat)[i];
--ndims;
/*
* Construct the expected result to a Python itemget call.
*/
rat = construct_md_array(elements, nulls, ndims, dims, lbs,
typinfo->typoid, typinfo->typlen, typinfo->typbyval, typinfo->typalign);
pfree(elements);
pfree(nulls);
pfree(xat);
rob = PyPgObject_New(Py_TYPE(self), PointerGetDatum(rat));
pfree(rat);
}
PG_CATCH();
{
PyErr_SetPgError(false);
return(NULL);
}
PG_END_TRY();
}
return(rob);
}
/*
* array_from_elements - classmethod to build an array
*/
static PyObj
array_from_elements(PyObj self, PyObj args, PyObj kw)
{
static char *kwlist[] = {"elements", "dimensions", "lowerbounds", NULL};
PyObj rob = NULL, iter, listob, dims_ob = NULL, lbs_ob = NULL;
int dims[MAXDIM];
int lbs[MAXDIM] = {1, 0,};
int ndims = 1, nelems;
Py_ssize_t i;
ArrayType *rat = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kw, "O|OO:from_elements",
kwlist, &iter, &dims_ob, &lbs_ob))
{
return(NULL);
}
listob = Py_Call((PyObj) &PyList_Type, iter);
if (listob == NULL)
return(NULL);
Assert(PyList_CheckExact(listob));
/*
* Convert the dimensions keyword into a tuple and extract the values
* into the dims[] array.
*/
if (dims_ob != NULL && dims_ob != Py_None)
{
PyObj tdims_ob;
tdims_ob = Py_Call((PyObj) &PyTuple_Type, dims_ob);
if (tdims_ob == NULL)
goto fail;
ndims = PyTuple_GET_SIZE(tdims_ob);
if (ndims > MAXDIM)
{
Py_DECREF(tdims_ob);
PyErr_Format(PyExc_ValueError, "too many dimensions (%d) for array",
ndims);
goto fail;
}
if (ndims > 0)
{
for (i = 0; i < ndims; ++i)
{
dims[i] = (int) PyNumber_AsSsize_t(PyTuple_GET_ITEM(tdims_ob, i),
NULL);
if (PyErr_Occurred())
{
Py_DECREF(tdims_ob);
goto fail;
}
}
}
else
dims[0] = 0;
Py_DECREF(tdims_ob);
}
else
{
dims[0] = PyList_GET_SIZE(listob);
if (dims[0] == 0)
ndims = 0;
}
nelems = dims[0];
if (ndims > 1)
{
for (i = 1; i < ndims; ++i)
nelems = nelems * dims[i];
}
if (nelems != PyList_GET_SIZE(listob))
{
PyErr_Format(PyExc_ValueError,
"dimension capacity (%d) does not accommodate the given elements (%d)",
nelems, PyList_GET_SIZE(listob));
goto fail;
}
if (lbs_ob != NULL && lbs_ob != Py_None)
{
PyObj tlbs_ob;
tlbs_ob = Py_Call((PyObj) &PyTuple_Type, lbs_ob);
if (tlbs_ob == NULL)
goto fail;
if (PyTuple_GET_SIZE(tlbs_ob) > MAXDIM)
{
Py_DECREF(tlbs_ob);
PyErr_SetString(PyExc_ValueError, "too many dimensions for array");
goto fail;
}
if (PyTuple_GET_SIZE(tlbs_ob) != ndims)
{
Py_DECREF(tlbs_ob);
PyErr_Format(PyExc_ValueError, "number of lower bounds (%d) is "
"inconsistent with dimensions (%d)",
PyTuple_GET_SIZE(tlbs_ob), ndims);
goto fail;
}
for (i = 0; i < PyTuple_GET_SIZE(tlbs_ob); ++i)
{
lbs[i] = (int) PyNumber_AsSsize_t(PyTuple_GET_ITEM(tlbs_ob, i),
NULL);
if (PyErr_Occurred())
{
Py_DECREF(tlbs_ob);
goto fail;
}
}
Py_DECREF(tlbs_ob);
}
else
{
/*
* No lower bounds specified, fill in with 1's.
*/
for (i = 0; i < ndims; ++i)
{
lbs[i] = 1;
}
}
rat = array_from_list_and_info(
PyPgType_GetElementType(self),
listob, -1, ndims, dims, lbs);
Py_DECREF(listob);
if (rat != NULL)
{
rob = PyPgObject_New(self, PointerGetDatum(rat));
pfree(rat);
}
return(rob);
fail:
Py_XDECREF(listob);
return(NULL);
}
/*
* array_element - get an iterator to all the elements in the array
*
* The short: deconstruct and build a list of element instances.
*/
static PyObj
array_elements(PyObj self)
{
PyObj element_type;
volatile PyObj rob = NULL;
PyPgTypeInfo typinfo;
element_type = PyPgType_GetElementType(Py_TYPE(self));
typinfo = PyPgTypeInfo(element_type);
/*
* Multiple dimensions, so get a slice.
*/
PG_TRY();
{
Datum *elements;
bool *nulls;
int i, nelems;
ArrayType *at;
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
deconstruct_array(at,
typinfo->typoid, typinfo->typlen, typinfo->typbyval, typinfo->typalign,
&elements, &nulls, &nelems
);
rob = PyList_New(nelems);
for (i = 0; i < nelems; ++i)
{
PyObj ob;
if (nulls[i])
{
ob = Py_None;
Py_INCREF(ob);
}
else
ob = PyPgObject_New(element_type, elements[i]);
if (ob == NULL)
{
Py_DECREF(rob);
rob = NULL;
break;
}
PyList_SET_ITEM(rob, i, ob);
}
pfree(elements);
pfree(nulls);
}
PG_CATCH();
{
Py_XDECREF(rob);
rob = NULL;
PyErr_SetPgError(false);
return(NULL);
}
PG_END_TRY();
return(rob);
}
static PyObj
array_sql_get_element(PyObj self, PyObj indexes_ob)
{
PyObj tup, element_type, rob = NULL;
PyPgTypeInfo atypinfo, typinfo;
ArrayType *at;
int i, nindexes, indexes[MAXDIM] = {0,};
/*
* Convert the dimensions keyword into a tuple and extract the values
* into the dims[] array.
*/
tup = Py_Call((PyObj) &PyTuple_Type, indexes_ob);
if (tup == NULL)
return(NULL);
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
Assert(at != NULL);
nindexes = (int) PyTuple_GET_SIZE(tup);
if (nindexes != ARR_NDIM(at))
{
Py_DECREF(tup);
Py_INCREF(Py_None);
return(Py_None);
}
for (i = 0; i < nindexes; ++i)
{
indexes[i] = (int) PyNumber_AsSsize_t(PyTuple_GET_ITEM(tup, i),
NULL);
if (PyErr_Occurred())
{
Py_DECREF(tup);
return(NULL);
}
}
Py_DECREF(tup);
atypinfo = PyPgTypeInfo(Py_TYPE(self));
element_type = PyPgType_GetElementType(Py_TYPE(self));
typinfo = PyPgTypeInfo(element_type);
/*
* Single dimenion array? Get an element.
*/
PG_TRY();
{
Datum rd;
bool isnull = false;
rd = array_ref(at, nindexes, indexes, atypinfo->typlen,
typinfo->typlen, typinfo->typbyval, typinfo->typalign, &isnull);
if (isnull)
{
rob = Py_None;
Py_INCREF(rob);
}
else
{
/*
* It points into the array structure, so there's no need to free.
*/
rob = PyPgObject_New(element_type, rd);
}
}
PG_CATCH();
{
PyErr_SetPgError(false);
}
PG_END_TRY();
return(rob);
}
static PyObj
func_call(PyObj self, PyObj args, PyObj kw)
{
MemoryContext former = CurrentMemoryContext;
PyObj fn_input, fn_output, input, rob = NULL;
TupleDesc td;
FmgrInfo flinfo;
FunctionCallInfoData fcinfo;
volatile Datum datum = 0;
/*
* Disallow execution of "anonymous" functions.
*/
flinfo.fn_addr = PyPgFunction_GetPGFunction(self);
flinfo.fn_oid = PyPgFunction_GetOid(self);
flinfo.fn_retset = PyPgFunction_GetReturnsSet(self);
if (flinfo.fn_addr == NULL || flinfo.fn_oid == InvalidOid)
{
PyErr_SetString(PyExc_TypeError, "internal functions are not directly callable");
return(NULL);
}
if (flinfo.fn_retset)
{
PyErr_SetString(PyExc_NotImplementedError,
"cannot directly execute set returning functions");
return(NULL);
}
fn_input = PyPgFunction_GetInput(self);
fn_output = PyPgFunction_GetOutput(self);
if (PyPgTupleDesc_IsPolymorphic(fn_input) ||
PyPgType_IsPolymorphic(fn_output))
{
PyErr_SetString(PyExc_NotImplementedError,
"cannot directly execute polymorphic functions");
return(NULL);
}
if (PyPgType_GetOid(fn_output) == TRIGGEROID)
{
PyErr_SetString(PyExc_NotImplementedError,
"cannot directly execute TRIGGER returning functions");
return(NULL);
}
/* No access if failed transaction */
if (DB_IS_NOT_READY())
return(NULL);
td = PyPgTupleDesc_GetTupleDesc(fn_input);
/*
* Normalize the parameters.
*/
input = PyTuple_FromTupleDescAndParameters(td, args, kw);
if (input == NULL)
return(NULL);
flinfo.fn_nargs = td->natts;
flinfo.fn_extra = NULL;
flinfo.fn_mcxt = CurrentMemoryContext;
flinfo.fn_expr = NULL;
fcinfo.flinfo = &flinfo;
fcinfo.context = NULL;
fcinfo.resultinfo = NULL;
fcinfo.isnull = false;
/*
* Custom built descriptor; no dropped attributes.
*/
fcinfo.nargs = td->natts;
SPI_push();
PG_TRY();
{
Py_BuildDatumsAndNulls(td,
PyPgTupleDesc_GetTypesTuple(fn_input),
input, fcinfo.arg, fcinfo.argnull);
datum = FunctionCallInvoke(&fcinfo);
/*
* Special casing void to avoid the singleton.
*/
if (fcinfo.isnull ||
PyPgType_GetOid(fn_output) == VOIDOID)
{
rob = Py_None;
Py_INCREF(rob);
}
else
{
/*
* Some functions will return a parameter that its given.
* This is problematic if we are going to free the output
* after re-allocating as a Postgres.Object.
*/
if (PyPgType_ShouldFree(fn_output))
{
int i;
/*
* Scan for !typbyval parameters.
* When one is found, compare the datum to the result datum.
*/
for (i = 0; i < PyTuple_GET_SIZE(input); ++i)
{
PyObj param = PyTuple_GET_ITEM(input, i);
/*
* It's tempting to check the types first, but in situations
* of functions doing binary compatible coercion, it would be a
* mistake.
*/
if (PyPgType_ShouldFree(Py_TYPE(param)))
{
if (PyPgObject_GetDatum(param) == datum)
{
/*
* It's the same Datum of an argument,
* inc the ref and return the param.
*/
if (fn_output == (PyObj) Py_TYPE(param))
{
rob = param;
Py_INCREF(rob);
}
else
{
/*
* It's the same Datum, but a different type.
* Make a Copy.
*/
rob = PyPgObject_New(fn_output, datum);
}
break;
}
}
}
/*
* It's a newly allocated result? (not an argument)
*/
if (rob == NULL)
{
/*
* New result, Datum is copied into the PythonMemoryContext
*/
rob = PyPgObject_New(fn_output, datum);
/*
* Cleanup.
*/
pfree(DatumGetPointer(datum));
}
}
else
{
/* Not pfree'ing typbyval, so no need to check parameters. */
rob = PyPgObject_New(fn_output, datum);
}
}
}
PG_CATCH();
{
Py_XDECREF(rob);
rob = NULL;
PyErr_SetPgError(false);
}
PG_END_TRY();
SPI_pop();
Py_DECREF(input);
MemoryContextSwitchTo(former);
return(rob);
}
