static PyObj
array_get_nelements(PyObj self, void *closure)
{
long nelements;
ArrayType *at;
int ndim, *dims;
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
ndim = ARR_NDIM(at);
dims = ARR_DIMS(at);
if (ndim == 0)
nelements = 0;
else
{
int i;
nelements = 1;
for (i = 0; i < ndim; ++i)
{
nelements = (dims[i] * nelements);
}
}
return(PyLong_FromLong(nelements));
}
static int
obj_bool(PyObj self)
{
int r;
/*
* Use self's Datum if it's a bool object.
* Otherwise, cast to a bool.
*/
if (PyPg_bool_Check(self))
r = DatumGetBool(PyPgObject_GetDatum(self)) ? 1 : 0;
else
{
Datum d;
bool isnull;
PG_TRY();
{
PyPgType_typcast((PyObj) &PyPg_bool_Type, self, -1, &d, &isnull);
if (isnull)
r = 0;
else
r = DatumGetBool(d) ? 1 : 0;
}
PG_CATCH();
{
r = -1;
PyErr_SetPgError(false);
}
PG_END_TRY();
}
return(r);
}
static PyObj
array_get_dimensions(PyObj self, void *closure)
{
ArrayType *at;
PyObj rob;
int i, ndim, *dims;
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
ndim = ARR_NDIM(at);
dims = ARR_DIMS(at);
rob = PyTuple_New(ndim);
for (i = 0; i < ndim; ++i)
{
PyObj ob;
ob = PyLong_FromLong(dims[i]);
if (ob == NULL)
{
Py_DECREF(rob);
return(NULL);
}
PyTuple_SET_ITEM(rob, i, ob);
}
return(rob);
}
static void
obj_dealloc(PyObj self)
{
Datum d = PyPgObject_GetDatum(self);
PyPgObject_SetDatum(self, 0);
if (PyPgType_ShouldFree(Py_TYPE(self)))
{
if (PointerIsValid(DatumGetPointer(d)))
{
MemoryContext former = CurrentMemoryContext;
PG_TRY();
{
pfree(DatumGetPointer(d));
/*
* When PLPY_STRANGE_THINGS is defined.
*/
RaiseAStrangeError
}
PG_CATCH();
{
PyErr_EmitPgErrorAsWarning("failed to deallocate Datum");
}
PG_END_TRY();
MemoryContextSwitchTo(former);
}
}
Py_TYPE(self)->tp_free(self);
}
static PyObj
array_get_ndim(PyObj self, void *closure)
{
PyObj rob;
rob = PyLong_FromLong(ARR_NDIM(DatumGetArrayTypeP(PyPgObject_GetDatum(self))));
return(rob);
}
/*
* len(o) - Python semantics
*/
static Py_ssize_t
py_array_length(PyObj self)
{
ArrayType *at;
at = DatumGetArrayTypeP(PyPgObject_GetDatum(self));
if (ARR_NDIM(at) == 0)
return(0);
else
return(ARR_DIMS(at)[0]);
}
static PyObj
array_has_null(PyObj self, void *closure)
{
PyObj rob;
if (ARR_HASNULL(DatumGetArrayTypeP(PyPgObject_GetDatum(self))))
rob = Py_True;
else
rob = Py_False;
Py_INCREF(rob);
return(rob);
}
static long
obj_hash(PyObj self)
{
PyPgTypeInfo typinfo;
Datum ob_datum = PyPgObject_GetDatum(self);
long rv = 0;
typinfo = PyPgTypeInfo(Py_TYPE(self));
if (typinfo->typbyval)
{
rv = ((long) ob_datum);
}
else if (typinfo->typlen > -1 && typinfo->typlen <= sizeof(long))
{
rv = (*((long *) DatumGetPointer(ob_datum)));
}
else
{
int len;
switch(typinfo->typlen)
{
case -2:
len = strlen((char *) DatumGetPointer(ob_datum));
break;
case -1:
len = VARSIZE(ob_datum) - VARHDRSZ;
ob_datum = PointerGetDatum(VARDATA(ob_datum));
break;
default:
len = (int) typinfo->typlen;
break;
}
rv = hash_any((unsigned char *) DatumGetPointer(ob_datum), len);
}
return(rv);
}
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
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);
}
/*
* 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);
}
/*
* 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);
}
/*
* XXX: If type methods ever come along, hopefully this will be implemented
* using a more generalized function.
*/
static PyObj
obj_absolute(PyObj self)
{
MemoryContext former;
Oid typoid;
volatile PyObj rob = NULL;
if (DB_IS_NOT_READY() || PyPgObjectType_Require(Py_TYPE(self)))
return(NULL);
typoid = PyPgType_GetOid(Py_TYPE(self));
former = CurrentMemoryContext;
PG_TRY();
{
HeapTuple procTuple;
Datum rd = 0;
Oid procoid, roid;
List *qnl;
qnl = stringToQualifiedNameList("abs");
procoid = LookupFuncName(qnl, 1, &(typoid), true);
list_free(qnl);
if (procoid == InvalidOid)
{
PyErr_Format(PyExc_LookupError,
"no such function named 'abs' for type %u", typoid);
return(NULL);
}
procTuple = SearchSysCache(PROCOID, procoid, 0, 0, 0);
if (procTuple == NULL)
{
PyErr_Format(PyExc_LookupError,
"no procedure with Oid %u", procoid);
return(NULL);
}
roid = ((Form_pg_proc) GETSTRUCT(procTuple))->prorettype;
ReleaseSysCache(procTuple);
rd = OidFunctionCall1(procoid, PyPgObject_GetDatum(self));
rob = PyPgObject_FromTypeOidAndDatum(roid, rd);
if (PyPgType_ShouldFree(Py_TYPE(rob)))
{
/*
* That's our datum...
*/
if (PyPgObject_GetDatum(self) != rd)
pfree(DatumGetPointer(rd));
}
}
PG_CATCH();
{
Py_XDECREF(rob);
PyErr_SetPgError(false);
return(NULL);
}
PG_END_TRY();
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);
}
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);
}
