#include "cxoModule.h"

#define CXO_ADD_INT_CONSTANT(name, value) \

if (PyModule_AddIntConstant(module, name, value) < 0) \

return NULL;

#define CXO_ADD_TYPE_OBJECT(name, type) \

Py_INCREF(type); \

if (PyModule_AddObject(module, name, (PyObject*) type) < 0) \

return NULL;

#define CXO_MAKE_TYPE_READY(type) \

if (PyType_Ready(type) < 0) \

return NULL;

PyObject *cxoWarningException = NULL;

PyObject *cxoErrorException = NULL;

PyObject *cxoInterfaceErrorException = NULL;

PyObject *cxoDatabaseErrorException = NULL;

PyObject *cxoDataErrorException = NULL;

PyObject *cxoOperationalErrorException = NULL;

PyObject *cxoIntegrityErrorException = NULL;

PyObject *cxoInternalErrorException = NULL;

PyObject *cxoProgrammingErrorException = NULL;

PyObject *cxoNotSupportedErrorException = NULL;

cxoFuture *cxoFutureObj = NULL;

dpiContext *cxoDpiContext = NULL;

dpiVersionInfo cxoClientVersionInfo;

static int cxoModule_setException(PyObject *module, PyObject **exception,

char *name, PyObject *baseException)

{

char buffer[100];

sprintf(buffer, "cx_Oracle.%s", name);

*exception = PyErr_NewException(buffer, baseException, NULL);

if (!*exception)

return -1;

return PyModule_AddObject(module, name, *exception);

}

static PyObject* cxoModule_makeDSN(PyObject* self, PyObject* args,

PyObject* keywordArgs)

{

static unsigned int numConnectDataArgs = 5;

static char *keywordList[] = { "host", "port", "sid", "service_name",

"region", "sharding_key", "super_sharding_key", NULL };

PyObject *result, *connectData, *hostObj, *portObj;

char connectDataFormat[72], *sourcePtr, *targetPtr;

PyObject *connectDataArgs[5], *formatArgsArray;

unsigned int i;

// parse arguments

for (i = 0; i < numConnectDataArgs; i++)

connectDataArgs[i] = NULL;

if (!PyArg_ParseTupleAndKeywords(args, keywordArgs, "OO|OOOOO",

keywordList, &hostObj, &portObj, &connectDataArgs[0],

&connectDataArgs[1], &connectDataArgs[2], &connectDataArgs[3],

&connectDataArgs[4]))

return NULL;

// create list for connect data format arguments

formatArgsArray = PyList_New(0);

if (!formatArgsArray)

return NULL;

// process each of the connect data arguments

// build up a format string and a list of format arguments

targetPtr = connectDataFormat;

*targetPtr = '\0';

for (i = 0; i < numConnectDataArgs; i++) {

if (connectDataArgs[i]) {

if (PyList_Append(formatArgsArray, connectDataArgs[i]) < 0) {

Py_DECREF(formatArgsArray);

return NULL;

}

sourcePtr = keywordList[i + 2];

*targetPtr++ = '(';

while (*sourcePtr)

*targetPtr++ = toupper(*sourcePtr++);

*targetPtr++ = '=';

*targetPtr++ = '%';

*targetPtr++ = 's';

*targetPtr++ = ')';

*targetPtr = '\0';

}

}

// determine connect data

connectData = cxoUtils_formatString(connectDataFormat,

PyList_AsTuple(formatArgsArray));

Py_DECREF(formatArgsArray);

if (!connectData)

return NULL;

// perform overall format

result = cxoUtils_formatString("(DESCRIPTION=(ADDRESS="

"(PROTOCOL=TCP)(HOST=%s)(PORT=%s))(CONNECT_DATA=%s))",

PyTuple_Pack(3, hostObj, portObj, connectData));

Py_DECREF(connectData);

return result;

}

static PyObject* cxoModule_clientVersion(PyObject* self, PyObject* args)

{

if (cxoUtils_initializeDPI() < 0)

return NULL;

return Py_BuildValue("(iiiii)", cxoClientVersionInfo.versionNum,

cxoClientVersionInfo.releaseNum, cxoClientVersionInfo.updateNum,

cxoClientVersionInfo.portReleaseNum,

cxoClientVersionInfo.portUpdateNum);

}

static PyObject* cxoModule_time(PyObject* self, PyObject* args)

{

PyErr_SetString(cxoNotSupportedErrorException,

"Oracle does not support time only variables");

return NULL;

}

static PyObject* cxoModule_timeFromTicks(PyObject* self, PyObject* args)

{

PyErr_SetString(cxoNotSupportedErrorException,

"Oracle does not support time only variables");

return NULL;

}

static PyObject* cxoModule_dateFromTicks(PyObject* self, PyObject* args)

{

return cxoTransform_dateFromTicks(args);

}

static PyObject* cxoModule_timestampFromTicks(PyObject* self, PyObject* args)

{

return cxoTransform_timestampFromTicks(args);

}

static PyMethodDef cxoModuleMethods[] = {

{ "makedsn", (PyCFunction) cxoModule_makeDSN,

METH_VARARGS | METH_KEYWORDS },

{ "Time", (PyCFunction) cxoModule_time, METH_VARARGS },

{ "DateFromTicks", (PyCFunction) cxoModule_dateFromTicks, METH_VARARGS },

{ "TimeFromTicks", (PyCFunction) cxoModule_timeFromTicks, METH_VARARGS },

{ "TimestampFromTicks", (PyCFunction) cxoModule_timestampFromTicks,

METH_VARARGS },

{ "clientversion", (PyCFunction) cxoModule_clientVersion, METH_NOARGS },

{ NULL }

};

#if PY_MAJOR_VERSION >= 3

static struct PyModuleDef cxoModuleDef = {

PyModuleDef_HEAD_INIT,

"cx_Oracle",

NULL,

-1,

cxoModuleMethods, // methods

NULL, // m_reload

NULL, // traverse

NULL, // clear

NULL // free

};

static PyObject *cxoModule_initialize(void)

{

PyObject *module;

#ifdef WITH_THREAD

PyEval_InitThreads();

// initialize transforms

if (cxoTransform_init() < 0)

return NULL;

// prepare the types for use by the module

CXO_MAKE_TYPE_READY(&cxoPyTypeBfileVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeBinaryVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeBlobVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeBooleanVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeClobVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeConnection);

CXO_MAKE_TYPE_READY(&cxoPyTypeCursor);

CXO_MAKE_TYPE_READY(&cxoPyTypeCursorVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeDateTimeVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeDeqOptions);

CXO_MAKE_TYPE_READY(&cxoPyTypeEnqOptions);

CXO_MAKE_TYPE_READY(&cxoPyTypeError);

CXO_MAKE_TYPE_READY(&cxoPyTypeFixedCharVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeFixedNcharVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeFuture);

CXO_MAKE_TYPE_READY(&cxoPyTypeIntervalVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeLob);

CXO_MAKE_TYPE_READY(&cxoPyTypeLongBinaryVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeLongStringVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeMsgProps);

CXO_MAKE_TYPE_READY(&cxoPyTypeMessage);

CXO_MAKE_TYPE_READY(&cxoPyTypeMessageQuery);

CXO_MAKE_TYPE_READY(&cxoPyTypeMessageRow);

CXO_MAKE_TYPE_READY(&cxoPyTypeMessageTable);

CXO_MAKE_TYPE_READY(&cxoPyTypeNativeFloatVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeNativeIntVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeNcharVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeNclobVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeNumberVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeObjectAttr);

CXO_MAKE_TYPE_READY(&cxoPyTypeObject);

CXO_MAKE_TYPE_READY(&cxoPyTypeObjectType);

CXO_MAKE_TYPE_READY(&cxoPyTypeObjectVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeRowidVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeSessionPool);

CXO_MAKE_TYPE_READY(&cxoPyTypeStringVar);

CXO_MAKE_TYPE_READY(&cxoPyTypeSubscr);

CXO_MAKE_TYPE_READY(&cxoPyTypeTimestampVar);

// initialize module and retrieve the dictionary

#if PY_MAJOR_VERSION >= 3

module = PyModule_Create(&cxoModuleDef);

module = Py_InitModule("cx_Oracle", cxoModuleMethods);

if (!module)

return NULL;

// create exception object and add it to the dictionary

if (cxoModule_setException(module, &cxoWarningException,

"Warning", CXO_BASE_EXCEPTION) < 0)

return NULL;

if (cxoModule_setException(module, &cxoErrorException,

"Error", CXO_BASE_EXCEPTION) < 0)

return NULL;

if (cxoModule_setException(module, &cxoInterfaceErrorException,

"InterfaceError", cxoErrorException) < 0)

return NULL;

if (cxoModule_setException(module, &cxoDatabaseErrorException,

"DatabaseError", cxoErrorException) < 0)

return NULL;

if (cxoModule_setException(module, &cxoDataErrorException,

"DataError", cxoDatabaseErrorException) < 0)

return NULL;

if (cxoModule_setException(module, &cxoOperationalErrorException,

"OperationalError", cxoDatabaseErrorException) < 0)

return NULL;

if (cxoModule_setException(module, &cxoIntegrityErrorException,

"IntegrityError", cxoDatabaseErrorException) < 0)

return NULL;

if (cxoModule_setException(module, &cxoInternalErrorException,

"InternalError", cxoDatabaseErrorException) < 0)

return NULL;

if (cxoModule_setException(module, &cxoProgrammingErrorException,

"ProgrammingError", cxoDatabaseErrorException) < 0)

return NULL;

if (cxoModule_setException(module, &cxoNotSupportedErrorException,

"NotSupportedError", cxoDatabaseErrorException) < 0)

return NULL;

// set up the types that are available

#if PY_MAJOR_VERSION >= 3

CXO_ADD_TYPE_OBJECT("Binary", &PyBytes_Type)

CXO_ADD_TYPE_OBJECT("Binary", &PyBuffer_Type)

CXO_ADD_TYPE_OBJECT("Connection", &cxoPyTypeConnection)

CXO_ADD_TYPE_OBJECT("Cursor", &cxoPyTypeCursor)

CXO_ADD_TYPE_OBJECT("Timestamp", cxoPyTypeDateTime)

CXO_ADD_TYPE_OBJECT("Date", cxoPyTypeDate)

CXO_ADD_TYPE_OBJECT("SessionPool", &cxoPyTypeSessionPool)

CXO_ADD_TYPE_OBJECT("_Error", &cxoPyTypeError)

CXO_ADD_TYPE_OBJECT("Object", &cxoPyTypeObject)

CXO_ADD_TYPE_OBJECT("ObjectType", &cxoPyTypeObjectType)

CXO_ADD_TYPE_OBJECT("EnqOptions", &cxoPyTypeEnqOptions)

CXO_ADD_TYPE_OBJECT("DeqOptions", &cxoPyTypeDeqOptions)

CXO_ADD_TYPE_OBJECT("MessageProperties", &cxoPyTypeMsgProps)

// the name "connect" is required by the DB API

CXO_ADD_TYPE_OBJECT("connect", &cxoPyTypeConnection)

// create the basic data types for setting input sizes

CXO_ADD_TYPE_OBJECT("BINARY", &cxoPyTypeBinaryVar)

CXO_ADD_TYPE_OBJECT("BFILE", &cxoPyTypeBfileVar)

CXO_ADD_TYPE_OBJECT("BLOB", &cxoPyTypeBlobVar)

CXO_ADD_TYPE_OBJECT("CLOB", &cxoPyTypeClobVar)

CXO_ADD_TYPE_OBJECT("CURSOR", &cxoPyTypeCursorVar)

CXO_ADD_TYPE_OBJECT("OBJECT", &cxoPyTypeObjectVar)

CXO_ADD_TYPE_OBJECT("DATETIME", &cxoPyTypeDateTimeVar)

CXO_ADD_TYPE_OBJECT("FIXED_CHAR", &cxoPyTypeFixedCharVar)

CXO_ADD_TYPE_OBJECT("FIXED_NCHAR", &cxoPyTypeFixedNcharVar)

CXO_ADD_TYPE_OBJECT("NCHAR", &cxoPyTypeNcharVar)

CXO_ADD_TYPE_OBJECT("INTERVAL", &cxoPyTypeIntervalVar)

CXO_ADD_TYPE_OBJECT("LOB", &cxoPyTypeLob)

CXO_ADD_TYPE_OBJECT("LONG_BINARY", &cxoPyTypeLongBinaryVar)

CXO_ADD_TYPE_OBJECT("LONG_STRING", &cxoPyTypeLongStringVar)

CXO_ADD_TYPE_OBJECT("NCLOB", &cxoPyTypeNclobVar)

CXO_ADD_TYPE_OBJECT("NUMBER", &cxoPyTypeNumberVar)

CXO_ADD_TYPE_OBJECT("ROWID", &cxoPyTypeRowidVar)

CXO_ADD_TYPE_OBJECT("STRING", &cxoPyTypeStringVar)

CXO_ADD_TYPE_OBJECT("TIMESTAMP", &cxoPyTypeTimestampVar)

CXO_ADD_TYPE_OBJECT("NATIVE_INT", &cxoPyTypeNativeIntVar)

CXO_ADD_TYPE_OBJECT("NATIVE_FLOAT", &cxoPyTypeNativeFloatVar)

CXO_ADD_TYPE_OBJECT("BOOLEAN", &cxoPyTypeBooleanVar)

// create constants required by Python DB API 2.0

if (PyModule_AddStringConstant(module, "apilevel", "2.0") < 0)

return NULL;

if (PyModule_AddIntConstant(module, "threadsafety", 2) < 0)

return NULL;

if (PyModule_AddStringConstant(module, "paramstyle", "named") < 0)

return NULL;

// add version and build time for easier support

if (PyModule_AddStringConstant(module, "version",

CXO_BUILD_VERSION_STRING) < 0)

return NULL;

if (PyModule_AddStringConstant(module, "__version__",

CXO_BUILD_VERSION_STRING) < 0)

return NULL;

if (PyModule_AddStringConstant(module, "buildtime",

__DATE__ " " __TIME__) < 0)

return NULL;

// create and initialize future object

cxoFutureObj = (cxoFuture*) cxoPyTypeFuture.tp_alloc(&cxoPyTypeFuture, 0);

if (!cxoFutureObj)

return NULL;

cxoFutureObj->contextManagerClose = 0;

if (PyModule_AddObject(module, "__future__", (PyObject*) cxoFutureObj) < 0)

return NULL;

// add constants for authorization modes

CXO_ADD_INT_CONSTANT("SYSASM", DPI_MODE_AUTH_SYSASM)

CXO_ADD_INT_CONSTANT("SYSBKP", DPI_MODE_AUTH_SYSBKP)

CXO_ADD_INT_CONSTANT("SYSDBA", DPI_MODE_AUTH_SYSDBA)

CXO_ADD_INT_CONSTANT("SYSDGD", DPI_MODE_AUTH_SYSDGD)

CXO_ADD_INT_CONSTANT("SYSKMT", DPI_MODE_AUTH_SYSKMT)

CXO_ADD_INT_CONSTANT("SYSOPER", DPI_MODE_AUTH_SYSOPER)

CXO_ADD_INT_CONSTANT("SYSRAC", DPI_MODE_AUTH_SYSRAC)

CXO_ADD_INT_CONSTANT("PRELIM_AUTH", DPI_MODE_AUTH_PRELIM)

// add constants for session pool get modes

CXO_ADD_INT_CONSTANT("SPOOL_ATTRVAL_WAIT", DPI_MODE_POOL_GET_WAIT)

CXO_ADD_INT_CONSTANT("SPOOL_ATTRVAL_NOWAIT", DPI_MODE_POOL_GET_NOWAIT)

CXO_ADD_INT_CONSTANT("SPOOL_ATTRVAL_FORCEGET", DPI_MODE_POOL_GET_FORCEGET)

// add constants for database shutdown modes

CXO_ADD_INT_CONSTANT("DBSHUTDOWN_ABORT", DPI_MODE_SHUTDOWN_ABORT)

CXO_ADD_INT_CONSTANT("DBSHUTDOWN_FINAL", DPI_MODE_SHUTDOWN_FINAL)

CXO_ADD_INT_CONSTANT("DBSHUTDOWN_IMMEDIATE", DPI_MODE_SHUTDOWN_IMMEDIATE)

CXO_ADD_INT_CONSTANT("DBSHUTDOWN_TRANSACTIONAL",

DPI_MODE_SHUTDOWN_TRANSACTIONAL)

CXO_ADD_INT_CONSTANT("DBSHUTDOWN_TRANSACTIONAL_LOCAL",

DPI_MODE_SHUTDOWN_TRANSACTIONAL_LOCAL)

// add constants for purity

CXO_ADD_INT_CONSTANT("ATTR_PURITY_DEFAULT", DPI_PURITY_DEFAULT)

CXO_ADD_INT_CONSTANT("ATTR_PURITY_NEW", DPI_PURITY_NEW)

CXO_ADD_INT_CONSTANT("ATTR_PURITY_SELF", DPI_PURITY_SELF)

// add constants for subscription protocols

CXO_ADD_INT_CONSTANT("SUBSCR_PROTO_OCI", DPI_SUBSCR_PROTO_CALLBACK)

CXO_ADD_INT_CONSTANT("SUBSCR_PROTO_MAIL", DPI_SUBSCR_PROTO_MAIL)

CXO_ADD_INT_CONSTANT("SUBSCR_PROTO_SERVER", DPI_SUBSCR_PROTO_PLSQL)

CXO_ADD_INT_CONSTANT("SUBSCR_PROTO_HTTP", DPI_SUBSCR_PROTO_HTTP)

// add constants for subscription quality of service

CXO_ADD_INT_CONSTANT("SUBSCR_QOS_RELIABLE", DPI_SUBSCR_QOS_RELIABLE)

CXO_ADD_INT_CONSTANT("SUBSCR_QOS_DEREG_NFY", DPI_SUBSCR_QOS_DEREG_NFY)

CXO_ADD_INT_CONSTANT("SUBSCR_QOS_ROWIDS", DPI_SUBSCR_QOS_ROWIDS)

CXO_ADD_INT_CONSTANT("SUBSCR_QOS_QUERY", DPI_SUBSCR_QOS_QUERY)

CXO_ADD_INT_CONSTANT("SUBSCR_QOS_BEST_EFFORT", DPI_SUBSCR_QOS_BEST_EFFORT)

// add constants for subscription namespaces

CXO_ADD_INT_CONSTANT("SUBSCR_NAMESPACE_DBCHANGE",

DPI_SUBSCR_NAMESPACE_DBCHANGE)

// add constants for event types

CXO_ADD_INT_CONSTANT("EVENT_NONE", DPI_EVENT_NONE)

CXO_ADD_INT_CONSTANT("EVENT_STARTUP", DPI_EVENT_STARTUP)

CXO_ADD_INT_CONSTANT("EVENT_SHUTDOWN", DPI_EVENT_SHUTDOWN)

CXO_ADD_INT_CONSTANT("EVENT_SHUTDOWN_ANY", DPI_EVENT_SHUTDOWN_ANY)

CXO_ADD_INT_CONSTANT("EVENT_DEREG", DPI_EVENT_DEREG)

CXO_ADD_INT_CONSTANT("EVENT_OBJCHANGE", DPI_EVENT_OBJCHANGE)

CXO_ADD_INT_CONSTANT("EVENT_QUERYCHANGE", DPI_EVENT_QUERYCHANGE)

// add constants for opcodes

CXO_ADD_INT_CONSTANT("OPCODE_ALLOPS", DPI_OPCODE_ALL_OPS)

CXO_ADD_INT_CONSTANT("OPCODE_ALLROWS", DPI_OPCODE_ALL_ROWS)

CXO_ADD_INT_CONSTANT("OPCODE_INSERT", DPI_OPCODE_INSERT)

CXO_ADD_INT_CONSTANT("OPCODE_UPDATE", DPI_OPCODE_UPDATE)

CXO_ADD_INT_CONSTANT("OPCODE_DELETE", DPI_OPCODE_DELETE)

CXO_ADD_INT_CONSTANT("OPCODE_ALTER", DPI_OPCODE_ALTER)

CXO_ADD_INT_CONSTANT("OPCODE_DROP", DPI_OPCODE_DROP)

// add constants for AQ dequeue modes

CXO_ADD_INT_CONSTANT("DEQ_BROWSE", DPI_MODE_DEQ_BROWSE)

CXO_ADD_INT_CONSTANT("DEQ_LOCKED", DPI_MODE_DEQ_LOCKED)

CXO_ADD_INT_CONSTANT("DEQ_REMOVE", DPI_MODE_DEQ_REMOVE)

CXO_ADD_INT_CONSTANT("DEQ_REMOVE_NODATA", DPI_MODE_DEQ_REMOVE_NO_DATA)

// add constants for AQ dequeue navigation

CXO_ADD_INT_CONSTANT("DEQ_FIRST_MSG", DPI_DEQ_NAV_FIRST_MSG)

CXO_ADD_INT_CONSTANT("DEQ_NEXT_TRANSACTION", DPI_DEQ_NAV_NEXT_TRANSACTION)

CXO_ADD_INT_CONSTANT("DEQ_NEXT_MSG", DPI_DEQ_NAV_NEXT_MSG)

// add constants for AQ dequeue visibility

CXO_ADD_INT_CONSTANT("DEQ_IMMEDIATE", DPI_VISIBILITY_IMMEDIATE)

CXO_ADD_INT_CONSTANT("DEQ_ON_COMMIT", DPI_VISIBILITY_ON_COMMIT)

// add constants for AQ dequeue wait

CXO_ADD_INT_CONSTANT("DEQ_NO_WAIT", DPI_DEQ_WAIT_NO_WAIT)

CXO_ADD_INT_CONSTANT("DEQ_WAIT_FOREVER", DPI_DEQ_WAIT_FOREVER)

// add constants for AQ enqueue visibility

CXO_ADD_INT_CONSTANT("ENQ_IMMEDIATE", DPI_VISIBILITY_IMMEDIATE)

CXO_ADD_INT_CONSTANT("ENQ_ON_COMMIT", DPI_VISIBILITY_ON_COMMIT)

// add constants for AQ table purge mode (message)

CXO_ADD_INT_CONSTANT("MSG_PERSISTENT", DPI_MODE_MSG_PERSISTENT)

CXO_ADD_INT_CONSTANT("MSG_BUFFERED", DPI_MODE_MSG_BUFFERED)

CXO_ADD_INT_CONSTANT("MSG_PERSISTENT_OR_BUFFERED",

DPI_MODE_MSG_PERSISTENT_OR_BUFFERED)

// add constants for AQ message state

CXO_ADD_INT_CONSTANT("MSG_EXPIRED", DPI_MSG_STATE_EXPIRED)

CXO_ADD_INT_CONSTANT("MSG_READY", DPI_MSG_STATE_READY)

CXO_ADD_INT_CONSTANT("MSG_PROCESSED", DPI_MSG_STATE_PROCESSED)

CXO_ADD_INT_CONSTANT("MSG_WAITING", DPI_MSG_STATE_WAITING)

// add special constants for AQ delay/expiration

CXO_ADD_INT_CONSTANT("MSG_NO_DELAY", 0)

CXO_ADD_INT_CONSTANT("MSG_NO_EXPIRATION", -1)

return module;

}

#if PY_MAJOR_VERSION >= 3

PyMODINIT_FUNC PyInit_cx_Oracle(void)

{

return cxoModule_initialize();

}

void initcx_Oracle(void)

{

cxoModule_initialize();

}