#include <setjmp.h>

#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include <structmember.h>

#include "postgres.h"

#include "access/heapam.h"

#include "access/transam.h"

#include "funcapi.h"

#include "catalog/pg_type.h"

#include "catalog/pg_cast.h"

#include "catalog/pg_namespace.h"

#include "commands/typecmds.h"

#include "executor/executor.h"

#include "nodes/params.h"

#include "parser/parse_type.h"

#include "tcop/dest.h"

#include "tcop/tcopprot.h"

#include "utils/builtins.h"

#include "utils/array.h"

#include "utils/datum.h"

#include "utils/memutils.h"

#include "utils/rel.h"

#include "utils/relcache.h"

#include "utils/syscache.h"

#include "utils/lsyscache.h"

#include "utils/typcache.h"

#include "utils/tuplestore.h"

#include "mb/pg_wchar.h"

#include "pypg/python.h"

#include "pypg/postgres.h"

#include "pypg/extension.h"

#include "pypg/pl.h"

#include "pypg/error.h"

#include "pypg/tupledesc.h"

#include "pypg/type/type.h"

#include "pypg/type/object.h"

#include "pypg/type/array.h"

#include "pypg/type/bitwise.h"

#include "pypg/type/record.h"

#include "pypg/type/numeric.h"

#include "pypg/type/string.h"

#include "pypg/type/timewise.h"

#include "pypg/type/system.h"

static PyObj type_anonymous_composites = NULL;

static PyObj type_cache = NULL;

PyObj PyPg_pg_attribute_Type = NULL;

PyObj PyPg_aclitem_Array_Type = NULL;

PyObj PyPg_cstring_Array_Type = NULL;

PyPgClearTypeCache(void)

{

PyDict_Clear(type_cache);

}

static bool

is_builtin(Oid typoid)

{

switch (typoid)

{

case CSTRINGARRAYOID:

case AttributeRelation_Rowtype_Id:

case ACLITEMOID + 1: /* ACLITEMARRAYOID? */

#define TYP(name) \

case PyPg_##name##_Type_oid:

PYPG_DB_TYPES()

#undef TYP

return(true);

break;

default:

return(false);

break;

}

Assert(false);

}

static void

clear_typinfo(PyPgTypeInfo typinfo)

{

PyObj ob;

/*

typinfo->typ_xmin = InvalidTransactionId;

/*

ob = typinfo->typname_PyUnicode;

typinfo->typname_PyUnicode = NULL;

Py_XDECREF(ob);

ob = typinfo->nspname_PyUnicode;

typinfo->nspname_PyUnicode = NULL;

Py_XDECREF(ob);

ob = typinfo->typoid_PyLong;

typinfo->typoid_PyLong = NULL;

Py_XDECREF(ob);

ob = typinfo->typnamespace_PyLong;

typinfo->typnamespace_PyLong = NULL;

Py_XDECREF(ob);

if (typinfo->typtype == TYPTYPE_ARRAY)

{

ob = typinfo->array.x_yes.typelem_Type;

typinfo->array.x_yes.typelem_Type = NULL;

Py_XDECREF(ob);

}

else

{

ob = typinfo->array.x_no.composite.typrel_TupleDesc;

typinfo->array.x_no.composite.typrel_TupleDesc = NULL;

Py_XDECREF(ob);

}

/*

if (typinfo->typmemory != PythonMemoryContext &&

typinfo->typmemory != NULL)

{

PG_TRY();

{

MemoryContextDelete(typinfo->typmemory);

/*

RaiseAStrangeError

}

PG_CATCH();

{

PyErr_EmitPgErrorAsWarning("deleting type memory context caused error");

}

PG_END_TRY();

typinfo->typmemory = NULL;

}

}

static void

inherit_typinfo(PyPgTypeInfo dst, PyPgTypeInfo src)

{

dst->typtype = src->typtype;

dst->typalign = src->typalign;

dst->typbyval = src->typbyval;

dst->typlen = src->typlen;

if (dst->typtype == TYPTYPE_ARRAY)

{

dst->array.x_yes.typelem =

src->array.x_yes.typelem;

dst->array.x_yes.typelem_Type =

src->array.x_yes.typelem_Type;

Py_XINCREF(dst->array.x_yes.typelem_Type);

}

else

{

dst->array.x_no.typarray =

src->array.x_no.typarray;

if (dst->typtype == TYPTYPE_COMPOSITE)

{

dst->array.x_no.composite.typrelid =

src->array.x_no.composite.typrelid;

dst->array.x_no.composite.typrel_TupleDesc =

src->array.x_no.composite.typrel_TupleDesc;

Py_XINCREF(dst->array.x_no.composite.typrel_TupleDesc);

}

}

}

PyPgType_IsCurrent(PyObj typ)

{

HeapTuple ht;

ItemPointerData typ_tid;

TransactionId typ_xmin;

Oid typoid;

typoid = PyPgType_GetOid(typ);

if (is_builtin(typoid))

return(true);

ht = SearchSysCache(TYPEOID, typoid, 0, 0, 0);

/* no longer exists? yeah, that's not current. */

if (!HeapTupleIsValid(ht))

return(false);

/*

typ_xmin = HeapTupleHeaderGetXmin(ht->t_data);

typ_tid = ht->t_self;

ReleaseSysCache(ht);

/*

if (PyPgType_IsComposite(typ) && (

PyPgType_GetXMin(typ) != typ_xmin ||

!ItemPointerEquals(PyPgType_GetItemPointer(typ), &typ_tid)))

{

return(false);

}

/*

if (PyPgType_IsComposite(typ))

{

Oid typrelid = PyPgType_GetTableOid(typ);

TupleDesc td = PyPgType_GetTupleDesc(typ);

/*

if (OidIsValid(typrelid))

{

Relation typrel;

typrel = RelationIdGetRelation(typrelid);

/* it doesn't exist? okay, it's not up-to-date */

if (typrel == NULL)

return(false);

if (typrel->rd_att->natts != td->natts)

{

RelationClose(typrel);

return(false);

}

else

{

/*

Form_pg_attribute *cur_atts = typrel->rd_att->attrs;

Form_pg_attribute *typ_atts = td->attrs;

int i;

for (i = 0; i < td->natts; ++i)

{

if (!(cur_atts[i]->attisdropped) != !(typ_atts[i]->attisdropped))

break; /* break to close relation */

}

RelationClose(typrel);

if (i < td->natts) /* it break'd out */

return(false);

}

}

/*

if (!PyPgTupleDesc_IsCurrent(PyPgType_GetPyPgTupleDesc(typ)))

return(false);

}

else if (PyPgType_IsArray(typ))

{

PyObj elem_Type = PyPgType_GetElementType(typ);

if (!PyPgType_IsCurrent(elem_Type))

return(false);

}

return(true);

}

static void

fill_fmgrinfo(struct pypg_type_func *typfunc, MemoryContext typcontext)

{

FmgrInfo *flinfo;

flinfo = &typfunc->typinput;

if (OidIsValid(flinfo->fn_oid))

fmgr_info_cxt(flinfo->fn_oid, flinfo, typcontext);

flinfo = &typfunc->typoutput;

if (OidIsValid(flinfo->fn_oid))

fmgr_info_cxt(flinfo->fn_oid, flinfo, typcontext);

flinfo = &typfunc->typreceive;

if (OidIsValid(flinfo->fn_oid))

fmgr_info_cxt(flinfo->fn_oid, flinfo, typcontext);

flinfo = &typfunc->typsend;

if (OidIsValid(flinfo->fn_oid))

fmgr_info_cxt(flinfo->fn_oid, flinfo, typcontext);

flinfo = &typfunc->typmodin;

if (OidIsValid(flinfo->fn_oid))

fmgr_info_cxt(flinfo->fn_oid, flinfo, typcontext);

flinfo = &typfunc->typmodout;

if (OidIsValid(flinfo->fn_oid))

fmgr_info_cxt(flinfo->fn_oid, flinfo, typcontext);

}

static int

fill_pg_type(PyPgTypeInfo typinfo)

{

MemoryContext former = CurrentMemoryContext;

volatile HeapTuple ht = NULL;

int r = 0;

TransactionId xmin;

ItemPointerData tid;

Assert(typinfo != NULL);

Assert(OidIsValid(typinfo->typoid));

Assert(!ext_state);

typinfo->typoid_PyLong = NULL;

typinfo->typnamespace_PyLong = NULL;

typinfo->typname_PyUnicode = NULL;

typinfo->nspname_PyUnicode = NULL;

PG_TRY();

{

Form_pg_type ts;

Form_pg_namespace ns;

ht = SearchSysCache(TYPEOID,

ObjectIdGetDatum(typinfo->typoid),

0, 0, 0);

if (!HeapTupleIsValid(ht))

{

ereport(ERROR, (

errcode(ERRCODE_UNDEFINED_OBJECT),

errmsg("type does not exist")));

}

/*

xmin = HeapTupleHeaderGetXmin(ht->t_data);

tid = ht->t_self;

/*

ts = (Form_pg_type) GETSTRUCT(ht);

if (!ts->typisdefined)

{

ereport(ERROR, (

errcode(ERRCODE_UNDEFINED_OBJECT),

errmsg("type is not defined")));

}

typinfo->typioparam = getTypeIOParam(ht);

/*

if (is_builtin(typinfo->typoid) == false)

{

typinfo->typmemory = AllocSetContextCreate(PythonMemoryContext,

NameStr(ts->typname),

ALLOCSET_SMALL_MINSIZE,

ALLOCSET_SMALL_INITSIZE,

ALLOCSET_SMALL_MAXSIZE);

}

else

typinfo->typmemory = PythonMemoryContext;

if (OidIsValid(ts->typbasetype))

{

/*

typinfo->domain.x_yes.typbasetype = ts->typbasetype;

typinfo->domain.x_yes.typndims = ts->typndims;

typinfo->domain.x_yes.typnotnull = ts->typnotnull;

/*

typinfo->typfunc = NULL;

MemoryContextSwitchTo(typinfo->typmemory);

typinfo->domain.x_yes.constraint_list =

GetDomainConstraints(typinfo->typoid);

MemoryContextSwitchTo(former);

/*

Assert(!is_builtin(typinfo->typoid));

}

else

{

typinfo->typbyval = ts->typbyval;

typinfo->typtype = ts->typtype;

/*

typinfo->typfunc = &(typinfo->domain.x_no);

typinfo->typfunc->typinput.fn_oid = ts->typinput;

typinfo->typfunc->typoutput.fn_oid = ts->typoutput;

typinfo->typfunc->typreceive.fn_oid = ts->typreceive;

typinfo->typfunc->typsend.fn_oid = ts->typsend;

typinfo->typfunc->typmodin.fn_oid = ts->typmodin;

typinfo->typfunc->typmodout.fn_oid = ts->typmodout;

/*

fill_fmgrinfo(typinfo->typfunc, typinfo->typmemory);

if (OidIsValid(ts->typelem))

{

/*

typinfo->array.x_yes.typelem = ts->typelem;

/*

typinfo->typtype = TYPTYPE_ARRAY;

Assert(ts->typelem != typinfo->typoid);

typinfo->array.x_yes.typelem_Type = PyPgType_FromOid(ts->typelem);

if (typinfo->array.x_yes.typelem_Type == NULL)

{

/*

RELEASESYSCACHE(&ht);

PyErr_RelayException();

}

}

else

{

if (OidIsValid(ts->typarray))

typinfo->array.x_no.typarray = ts->typarray;

/*

if (OidIsValid(ts->typrelid))

{

Relation rd;

rd = RelationIdGetRelation(ts->typrelid);

if (rd == NULL)

{

RELEASESYSCACHE(&ht);

elog(ERROR, "relation %u of type %u not found", ts->typrelid, typinfo->typoid);

}

typinfo->array.x_no.composite.typrelid = ts->typrelid;

typinfo->array.x_no.composite.typrel_TupleDesc =

PyPgTupleDesc_FromCopy(rd->rd_att);

RelationClose(rd);

}

}

typinfo->typcategory = _PG_GET_TYPCATEGORY(ts);

typinfo->typalign = ts->typalign;

typinfo->typlen = ts->typlen;

typinfo->typnamespace = ts->typnamespace;

}

/*

typinfo->typname_PyUnicode =

PyUnicode_FromCString(NameStr(ts->typname));

RELEASESYSCACHE(&ht); /* done with pg_type entry */

/*

ht = SearchSysCache(NAMESPACEOID,

ObjectIdGetDatum(typinfo->typnamespace), 0, 0, 0);

if (!HeapTupleIsValid(ht))

elog(ERROR,

"cache lookup failed for namespace %u", typinfo->typnamespace);

ns = (Form_pg_namespace) GETSTRUCT(ht);

typinfo->nspname_PyUnicode =

PyUnicode_FromCString(NameStr(ns->nspname));

RELEASESYSCACHE(&ht); /* done with pg_namespace entry */

/*

typinfo->typ_xmin = xmin;

typinfo->typ_tid = tid;

/*

typinfo->typoid_PyLong = PyLong_FromUnsignedLong(typinfo->typoid);

typinfo->typnamespace_PyLong =

PyLong_FromUnsignedLong(typinfo->typnamespace);

}

PG_CATCH();

{

r = -1;

if (ht != NULL)

ReleaseSysCache(ht);

MemoryContextSwitchTo(former);

clear_typinfo(typinfo);

PyErr_SetPgError(false);

}

PG_END_TRY();

/*

if (r == 0 && (

typinfo->typoid_PyLong == NULL ||

typinfo->typname_PyUnicode == NULL ||

typinfo->nspname_PyUnicode == NULL ||

typinfo->typnamespace_PyLong == NULL))

{

clear_typinfo(typinfo);

r = -1;

}

Assert((r != 0 && PyErr_Occurred()) || (r == 0 && !PyErr_Occurred()));

return(r);

}

static PyObj

create_heap_type(PyPgTypeInfo typinfo)

{

PyPgTypeInfo btypinfo;

PyObj base, bases, nbd, d, rob;

/*

bases = PyTuple_New(1);

if (bases == NULL)

return(NULL);

d = PyDict_New();

if (d == NULL)

{

Py_DECREF(bases);

return(NULL);

}

/*

if (PyDict_SetItemString(d, "__module__", typinfo->nspname_PyUnicode))

{

Py_DECREF(bases);

Py_DECREF(d);

return(NULL);

}

/*

nbd = PyTuple_New(3);

if (nbd == NULL)

{

Py_DECREF(bases);

Py_DECREF(d);

return(NULL);

}

/*

PyTuple_SET_ITEM(nbd, 0, typinfo->typname_PyUnicode);

Py_INCREF(typinfo->typname_PyUnicode);

PyTuple_SET_ITEM(nbd, 1, bases);

PyTuple_SET_ITEM(nbd, 2, d);

/*

if (typinfo_is_domain(typinfo))

{

base = PyPgType_FromOid(typinfo->domain.x_yes.typbasetype);

if (base == NULL)

{

Py_DECREF(nbd);

return(NULL);

}

btypinfo = PyPgTypeInfo(base);

/*

if (typinfo_is_domain(btypinfo))

{

typinfo->domain.x_yes.typubase_Type =

btypinfo->domain.x_yes.typubase_Type;

}

else

{

typinfo->domain.x_yes.typubase_Type = base;

}

inherit_typinfo(typinfo, btypinfo);

typinfo->typfunc = btypinfo->typfunc;

/* Should be the ultimate base's domain.x_no */

Assert(typinfo->typfunc == &(PyPgTypeInfo(typinfo->domain.x_yes.typubase_Type)->domain.x_no));

}

else

{

switch (typinfo->typtype)

{

case TYPTYPE_COMPOSITE:

base = (PyObj) &PyPg_record_Type;

break;

case TYPTYPE_PSEUDO:

base = (PyObj) &PyPgPseudo_Type;

break;

/* Note: TYPTYPE_ARRAY is contrived in pypg/type/type.h */

case TYPTYPE_ARRAY:

base = (PyObj) &PyPgArray_Type;

break;

default:

{

switch (typinfo->typcategory)

{

case TYPCATEGORY_STRING:

base = (PyObj) &PyPgString_Type;

break;

default:

base = (PyObj) &PyPgObject_Type;

break;

}

}

break;

}

Py_INCREF(base);

btypinfo = PyPgTypeInfo(base);

}

typinfo->tp_new_datum = btypinfo->tp_new_datum;

/*

PyTuple_SET_ITEM(bases, 0, base);

/*

Assert(Py_TYPE(base) == (PyTypeObject *) &PyPgType_Type);

rob = PyType_Type.tp_new((PyTypeObject *) Py_TYPE(base), nbd, NULL);

Py_DECREF(nbd);

/*

if (rob != NULL)

{

PyPgTypeInfo rtypinfo = PyPgTypeInfo(rob);

memcpy(rtypinfo, typinfo, sizeof(struct PyPgTypeInfo));

if (btypinfo->typfunc != rtypinfo->typfunc)

{

/*

rtypinfo->typfunc = &(rtypinfo->domain.x_no);

}

}

return(rob);

}

PyPgType_LookupBuiltin(Oid typoid)

{

PyObj rob;

switch (typoid)

{

#define TYP(name) \

case PyPg_##name##_Type_oid: rob = ((PyObj) &PyPg_##name##_Type); break;

PYPG_DB_TYPES()

#undef TYP

case AttributeRelation_Rowtype_Id:

rob = PyPg_pg_attribute_Type;

break;

case CSTRINGARRAYOID:

rob = PyPg_cstring_Array_Type;

break;

/*

case ACLITEMOID + 1:

rob = PyPg_aclitem_Array_Type;

break;

default:

/*

rob = NULL;

break;

}

return(rob);

}

PyPgType_FromOid(Oid typoid)

{

PyObj typoid_ob, rob = NULL;

if (DB_IS_NOT_READY())

return(NULL);

rob = PyPgType_LookupBuiltin(typoid);

if (rob == NULL)

{

/*

struct PyPgTypeInfo typinfo = PYPG_INIT_TYPINFO(invalid);

int contains;

typoid_ob = PyLong_FromUnsignedLong(typoid);

if (typoid_ob == NULL)

return(NULL);

contains = PySequence_Contains(type_cache, typoid_ob);

if (contains == -1)

{

Py_DECREF(typoid_ob);

return(NULL);

}

if (contains)

{

bool is_current;

rob = PyDict_GetItem(type_cache, typoid_ob);

Assert(rob != NULL); /* "typoid_ob in type_cache" said yessir. */

/*

PG_TRY();

{

is_current = PyPgType_IsCurrent(rob);

}

PG_CATCH();

{

Py_DECREF(typoid_ob);

PyErr_SetPgError(false);

return(NULL);

}

PG_END_TRY();

if (is_current)

{

/*

Py_DECREF(typoid_ob);

Py_INCREF(rob);

return(rob);

}

/*

if (PyDict_DelItem(type_cache, typoid_ob))

{

/* not likely, but okay, fail out... */

Py_DECREF(typoid_ob);

return(NULL);

}

rob = NULL;

}

/*

typinfo.typoid = typoid;

if (fill_pg_type(&typinfo))

{

/*

Py_DECREF(typoid_ob);

return(NULL);

}

/*

rob = create_heap_type(&typinfo);

if (rob == NULL)

{

Py_DECREF(typoid_ob);

clear_typinfo(&typinfo);

return(NULL);

}

if (PyDict_SetItem(type_cache, typoid_ob, rob))

{

/*

Py_DECREF(typoid_ob);

Py_DECREF(rob);

return(NULL);

}

}

else

{

/*

PyPgTypeInfo typinfo = PyPgTypeInfo(rob);

if (typinfo->typ_xmin == InvalidTransactionId)

{

/*

if (fill_pg_type(typinfo))

{

/*

return(NULL);

}

/*

Assert(!typinfo_is_domain(typinfo));

}

/*

Py_INCREF(rob);

}

return(rob);

}

PyPgType_FromPyPgTupleDesc(PyObj td_ob, PyObj typname)

{

PyPgTypeInfo btypinfo;

struct PyPgTypeInfo typinfo;

PyObj rob;

bzero(&typinfo, sizeof(struct PyPgTypeInfo));

btypinfo = PyPgTypeInfo(&PyPg_record_Type);

typinfo.typoid = RECORDOID;

typinfo.typtype = TYPTYPE_COMPOSITE;

typinfo.typnamespace = InvalidOid;

typinfo.typtype = btypinfo->typtype;

typinfo.typalign = btypinfo->typalign;

typinfo.typbyval = btypinfo->typbyval;

typinfo.typlen = btypinfo->typlen;

/*

typinfo.typ_xmin = btypinfo->typ_xmin;

typinfo.typ_tid = btypinfo->typ_tid;

typinfo.typfunc = &(typinfo.domain.x_no);

typinfo.domain.x_no.typinput.fn_oid = btypinfo->domain.x_no.typinput.fn_oid;

typinfo.domain.x_no.typoutput.fn_oid = btypinfo->domain.x_no.typoutput.fn_oid;

typinfo.domain.x_no.typreceive.fn_oid = btypinfo->domain.x_no.typreceive.fn_oid;

typinfo.domain.x_no.typsend.fn_oid = btypinfo->domain.x_no.typsend.fn_oid;

typinfo.domain.x_no.typmodin.fn_oid = btypinfo->domain.x_no.typmodin.fn_oid;

typinfo.domain.x_no.typmodout.fn_oid = btypinfo->domain.x_no.typmodout.fn_oid;

PG_TRY();

{

typinfo.typmemory = AllocSetContextCreate(PythonMemoryContext,

"PythonRecordTypeMemoryContext",

ALLOCSET_SMALL_MINSIZE,

ALLOCSET_SMALL_INITSIZE,

ALLOCSET_SMALL_MAXSIZE);

/*

fill_fmgrinfo(typinfo.typfunc, typinfo.typmemory);

}

PG_CATCH();