Remove Elixir library

Update SQLAlchemy
2014-01-26 16:29:16 +01:00
parent f91081e39c
commit 1120b4ab51
178 changed files with 43610 additions and 35304 deletions
@@ -1,6 +1,7 @@
 /*
 processors.c
-Copyright (C) 2010 Gaetan de Menten gdementen@gmail.com
+Copyright (C) 2010-2014 the SQLAlchemy authors and contributors <see AUTHORS file>
+Copyright (C) 2010-2011 Gaetan de Menten gdementen@gmail.com

 This module is part of SQLAlchemy and is released under
 the MIT License: http://www.opensource.org/licenses/mit-license.php
@@ -9,13 +10,15 @@ the MIT License: http://www.opensource.org/licenses/mit-license.php
 #include <Python.h>
 #include <datetime.h>

+#define MODULE_NAME "cprocessors"
+#define MODULE_DOC "Module containing C versions of data processing functions."
+
 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 typedef int Py_ssize_t;
 #define PY_SSIZE_T_MAX INT_MAX
 #define PY_SSIZE_T_MIN INT_MIN
 #endif

-
 static PyObject *
 int_to_boolean(PyObject *self, PyObject *arg)
 {
@@ -25,7 +28,12 @@ int_to_boolean(PyObject *self, PyObject *arg)
    if (arg == Py_None)
        Py_RETURN_NONE;

+
+#if PY_MAJOR_VERSION >= 3
+    l = PyLong_AsLong(arg);
+#else
    l = PyInt_AsLong(arg);
+#endif
    if (l == 0) {
        res = Py_False;
    } else if (l == 1) {
@@ -64,23 +72,48 @@ to_float(PyObject *self, PyObject *arg)
 static PyObject *
 str_to_datetime(PyObject *self, PyObject *arg)
 {
+#if PY_MAJOR_VERSION >= 3
+    PyObject *bytes;
+    PyObject *err_bytes;
+#endif
    const char *str;
+    int numparsed;
    unsigned int year, month, day, hour, minute, second, microsecond = 0;
    PyObject *err_repr;

    if (arg == Py_None)
        Py_RETURN_NONE;

+#if PY_MAJOR_VERSION >= 3
+    bytes = PyUnicode_AsASCIIString(arg);
+    if (bytes == NULL)
+        str = NULL;
+    else
+        str = PyBytes_AS_STRING(bytes);
+#else
    str = PyString_AsString(arg);
+#endif
    if (str == NULL) {
        err_repr = PyObject_Repr(arg);
        if (err_repr == NULL)
            return NULL;
+#if PY_MAJOR_VERSION >= 3
+        err_bytes = PyUnicode_AsASCIIString(err_repr);
+        if (err_bytes == NULL)
+            return NULL;
+        PyErr_Format(
+                PyExc_ValueError,
+                "Couldn't parse datetime string '%.200s' "
+                "- value is not a string.",
+                PyBytes_AS_STRING(err_bytes));
+        Py_DECREF(err_bytes);
+#else
        PyErr_Format(
                PyExc_ValueError,
                "Couldn't parse datetime string '%.200s' "
                "- value is not a string.",
                PyString_AsString(err_repr));
+#endif
        Py_DECREF(err_repr);
        return NULL;
    }
@@ -91,15 +124,30 @@ str_to_datetime(PyObject *self, PyObject *arg)
    not accept "2000-01-01 00:00:00.". I don't know which is better, but they
    should be coherent.
    */
-    if (sscanf(str, "%4u-%2u-%2u %2u:%2u:%2u.%6u", &year, &month, &day,
-               &hour, &minute, &second, &microsecond) < 6) {
+    numparsed = sscanf(str, "%4u-%2u-%2u %2u:%2u:%2u.%6u", &year, &month, &day,
+                       &hour, &minute, &second, &microsecond);
+#if PY_MAJOR_VERSION >= 3
+    Py_DECREF(bytes);
+#endif
+    if (numparsed < 6) {
        err_repr = PyObject_Repr(arg);
        if (err_repr == NULL)
            return NULL;
+#if PY_MAJOR_VERSION >= 3
+        err_bytes = PyUnicode_AsASCIIString(err_repr);
+        if (err_bytes == NULL)
+            return NULL;
+        PyErr_Format(
+                PyExc_ValueError,
+                "Couldn't parse datetime string: %.200s",
+                PyBytes_AS_STRING(err_bytes));
+        Py_DECREF(err_bytes);
+#else
        PyErr_Format(
                PyExc_ValueError,
                "Couldn't parse datetime string: %.200s",
                PyString_AsString(err_repr));
+#endif
        Py_DECREF(err_repr);
        return NULL;
    }
@@ -110,22 +158,47 @@ str_to_datetime(PyObject *self, PyObject *arg)
 static PyObject *
 str_to_time(PyObject *self, PyObject *arg)
 {
+#if PY_MAJOR_VERSION >= 3
+    PyObject *bytes;
+    PyObject *err_bytes;
+#endif
    const char *str;
+    int numparsed;
    unsigned int hour, minute, second, microsecond = 0;
    PyObject *err_repr;

    if (arg == Py_None)
        Py_RETURN_NONE;

+#if PY_MAJOR_VERSION >= 3
+    bytes = PyUnicode_AsASCIIString(arg);
+    if (bytes == NULL)
+        str = NULL;
+    else
+        str = PyBytes_AS_STRING(bytes);
+#else
    str = PyString_AsString(arg);
+#endif
    if (str == NULL) {
        err_repr = PyObject_Repr(arg);
        if (err_repr == NULL)
            return NULL;
+
+#if PY_MAJOR_VERSION >= 3
+        err_bytes = PyUnicode_AsASCIIString(err_repr);
+        if (err_bytes == NULL)
+            return NULL;
+        PyErr_Format(
+                PyExc_ValueError,
+                "Couldn't parse time string '%.200s' - value is not a string.",
+                PyBytes_AS_STRING(err_bytes));
+        Py_DECREF(err_bytes);
+#else
        PyErr_Format(
                PyExc_ValueError,
                "Couldn't parse time string '%.200s' - value is not a string.",
                PyString_AsString(err_repr));
+#endif
        Py_DECREF(err_repr);
        return NULL;
    }
@@ -136,15 +209,30 @@ str_to_time(PyObject *self, PyObject *arg)
    not accept "00:00:00.". I don't know which is better, but they should be
    coherent.
    */
-    if (sscanf(str, "%2u:%2u:%2u.%6u", &hour, &minute, &second,
-               &microsecond) < 3) {
+    numparsed = sscanf(str, "%2u:%2u:%2u.%6u", &hour, &minute, &second,
+                       &microsecond);
+#if PY_MAJOR_VERSION >= 3
+    Py_DECREF(bytes);
+#endif
+    if (numparsed < 3) {
        err_repr = PyObject_Repr(arg);
        if (err_repr == NULL)
            return NULL;
+#if PY_MAJOR_VERSION >= 3
+        err_bytes = PyUnicode_AsASCIIString(err_repr);
+        if (err_bytes == NULL)
+            return NULL;
+        PyErr_Format(
+                PyExc_ValueError,
+                "Couldn't parse time string: %.200s",
+                PyBytes_AS_STRING(err_bytes));
+        Py_DECREF(err_bytes);
+#else
        PyErr_Format(
                PyExc_ValueError,
                "Couldn't parse time string: %.200s",
                PyString_AsString(err_repr));
+#endif
        Py_DECREF(err_repr);
        return NULL;
    }
@@ -154,34 +242,73 @@ str_to_time(PyObject *self, PyObject *arg)
 static PyObject *
 str_to_date(PyObject *self, PyObject *arg)
 {
+#if PY_MAJOR_VERSION >= 3
+    PyObject *bytes;
+    PyObject *err_bytes;
+#endif
    const char *str;
+    int numparsed;
    unsigned int year, month, day;
    PyObject *err_repr;

    if (arg == Py_None)
        Py_RETURN_NONE;

+#if PY_MAJOR_VERSION >= 3
+    bytes = PyUnicode_AsASCIIString(arg);
+    if (bytes == NULL)
+        str = NULL;
+    else
+        str = PyBytes_AS_STRING(bytes);
+#else
    str = PyString_AsString(arg);
+#endif
    if (str == NULL) {
        err_repr = PyObject_Repr(arg);
        if (err_repr == NULL)
            return NULL;
+#if PY_MAJOR_VERSION >= 3
+        err_bytes = PyUnicode_AsASCIIString(err_repr);
+        if (err_bytes == NULL)
+            return NULL;
+        PyErr_Format(
+                PyExc_ValueError,
+                "Couldn't parse date string '%.200s' - value is not a string.",
+                PyBytes_AS_STRING(err_bytes));
+        Py_DECREF(err_bytes);
+#else
        PyErr_Format(
                PyExc_ValueError,
                "Couldn't parse date string '%.200s' - value is not a string.",
                PyString_AsString(err_repr));
+#endif
        Py_DECREF(err_repr);
        return NULL;
    }

-    if (sscanf(str, "%4u-%2u-%2u", &year, &month, &day) != 3) {
+    numparsed = sscanf(str, "%4u-%2u-%2u", &year, &month, &day);
+#if PY_MAJOR_VERSION >= 3
+    Py_DECREF(bytes);
+#endif
+    if (numparsed != 3) {
        err_repr = PyObject_Repr(arg);
        if (err_repr == NULL)
            return NULL;
+#if PY_MAJOR_VERSION >= 3
+        err_bytes = PyUnicode_AsASCIIString(err_repr);
+        if (err_bytes == NULL)
+            return NULL;
+        PyErr_Format(
+                PyExc_ValueError,
+                "Couldn't parse date string: %.200s",
+                PyBytes_AS_STRING(err_bytes));
+        Py_DECREF(err_bytes);
+#else
        PyErr_Format(
                PyExc_ValueError,
                "Couldn't parse date string: %.200s",
                PyString_AsString(err_repr));
+#endif
        Py_DECREF(err_repr);
        return NULL;
    }
@@ -218,17 +345,35 @@ UnicodeResultProcessor_init(UnicodeResultProcessor *self, PyObject *args,
    PyObject *encoding, *errors = NULL;
    static char *kwlist[] = {"encoding", "errors", NULL};

+#if PY_MAJOR_VERSION >= 3
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "U|U:__init__", kwlist,
+                                     &encoding, &errors))
+        return -1;
+#else
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "S|S:__init__", kwlist,
                                     &encoding, &errors))
        return -1;
+#endif

+#if PY_MAJOR_VERSION >= 3
+    encoding = PyUnicode_AsASCIIString(encoding);
+#else
    Py_INCREF(encoding);
+#endif
    self->encoding = encoding;

    if (errors) {
+#if PY_MAJOR_VERSION >= 3
+        errors = PyUnicode_AsASCIIString(errors);
+#else
        Py_INCREF(errors);
+#endif
    } else {
+#if PY_MAJOR_VERSION >= 3
+        errors = PyBytes_FromString("strict");
+#else
        errors = PyString_FromString("strict");
+#endif
        if (errors == NULL)
            return -1;
    }
@@ -247,11 +392,19 @@ UnicodeResultProcessor_process(UnicodeResultProcessor *self, PyObject *value)
    if (value == Py_None)
        Py_RETURN_NONE;

+#if PY_MAJOR_VERSION >= 3
+    if (PyBytes_AsStringAndSize(value, &str, &len))
+        return NULL;
+
+    encoding = PyBytes_AS_STRING(self->encoding);
+    errors = PyBytes_AS_STRING(self->errors);
+#else
    if (PyString_AsStringAndSize(value, &str, &len))
        return NULL;

    encoding = PyString_AS_STRING(self->encoding);
    errors = PyString_AS_STRING(self->errors);
+#endif

    return PyUnicode_Decode(str, len, encoding, errors);
 }
@@ -261,7 +414,11 @@ UnicodeResultProcessor_dealloc(UnicodeResultProcessor *self)
 {
    Py_XDECREF(self->encoding);
    Py_XDECREF(self->errors);
+#if PY_MAJOR_VERSION >= 3
+    Py_TYPE(self)->tp_free((PyObject*)self);
+#else
    self->ob_type->tp_free((PyObject*)self);
+#endif
 }

 static PyMethodDef UnicodeResultProcessor_methods[] = {
@@ -271,8 +428,7 @@ static PyMethodDef UnicodeResultProcessor_methods[] = {
 };

 static PyTypeObject UnicodeResultProcessorType = {
-    PyObject_HEAD_INIT(NULL)
-    0,                                          /* ob_size */
+    PyVarObject_HEAD_INIT(NULL, 0)
    "sqlalchemy.cprocessors.UnicodeResultProcessor",        /* tp_name */
    sizeof(UnicodeResultProcessor),             /* tp_basicsize */
    0,                                          /* tp_itemsize */
@@ -322,7 +478,11 @@ DecimalResultProcessor_init(DecimalResultProcessor *self, PyObject *args,
 {
    PyObject *type, *format;

+#if PY_MAJOR_VERSION >= 3
+    if (!PyArg_ParseTuple(args, "OU", &type, &format))
+#else
    if (!PyArg_ParseTuple(args, "OS", &type, &format))
+#endif
        return -1;

    Py_INCREF(type);
@@ -342,11 +502,21 @@ DecimalResultProcessor_process(DecimalResultProcessor *self, PyObject *value)
    if (value == Py_None)
        Py_RETURN_NONE;

+    /* Decimal does not accept float values directly */
+    /* SQLite can also give us an integer here (see [ticket:2432]) */
+    /* XXX: starting with Python 3.1, we could use Decimal.from_float(f),
+                 but the result wouldn't be the same */
+
    args = PyTuple_Pack(1, value);
    if (args == NULL)
        return NULL;

+#if PY_MAJOR_VERSION >= 3
+    str = PyUnicode_Format(self->format, args);
+#else
    str = PyString_Format(self->format, args);
+#endif
+
    Py_DECREF(args);
    if (str == NULL)
        return NULL;
@@ -361,7 +531,11 @@ DecimalResultProcessor_dealloc(DecimalResultProcessor *self)
 {
    Py_XDECREF(self->type);
    Py_XDECREF(self->format);
+#if PY_MAJOR_VERSION >= 3
+    Py_TYPE(self)->tp_free((PyObject*)self);
+#else
    self->ob_type->tp_free((PyObject*)self);
+#endif
 }

 static PyMethodDef DecimalResultProcessor_methods[] = {
@@ -371,8 +545,7 @@ static PyMethodDef DecimalResultProcessor_methods[] = {
 };

 static PyTypeObject DecimalResultProcessorType = {
-    PyObject_HEAD_INIT(NULL)
-    0,                                          /* ob_size */
+    PyVarObject_HEAD_INIT(NULL, 0)
    "sqlalchemy.DecimalResultProcessor",        /* tp_name */
    sizeof(DecimalResultProcessor),             /* tp_basicsize */
    0,                                          /* tp_itemsize */
@@ -412,11 +585,6 @@ static PyTypeObject DecimalResultProcessorType = {
    0,                                          /* tp_new */
 };

-#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
-#define PyMODINIT_FUNC void
-#endif
-
-
 static PyMethodDef module_methods[] = {
    {"int_to_boolean", int_to_boolean, METH_O,
     "Convert an integer to a boolean."},
@@ -433,23 +601,53 @@ static PyMethodDef module_methods[] = {
    {NULL, NULL, 0, NULL}        /* Sentinel */
 };

+#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
+#define PyMODINIT_FUNC void
+#endif
+
+
+#if PY_MAJOR_VERSION >= 3
+
+static struct PyModuleDef module_def = {
+    PyModuleDef_HEAD_INIT,
+    MODULE_NAME,
+    MODULE_DOC,
+    -1,
+    module_methods
+};
+
+#define INITERROR return NULL
+
+PyObject *
+PyInit_cprocessors(void)
+
+#else
+
+#define INITERROR return
+
 PyMODINIT_FUNC
 initcprocessors(void)
+
+#endif
+
 {
    PyObject *m;

    UnicodeResultProcessorType.tp_new = PyType_GenericNew;
    if (PyType_Ready(&UnicodeResultProcessorType) < 0)
-        return;
+        INITERROR;

    DecimalResultProcessorType.tp_new = PyType_GenericNew;
    if (PyType_Ready(&DecimalResultProcessorType) < 0)
-        return;
+        INITERROR;

-    m = Py_InitModule3("cprocessors", module_methods,
-                       "Module containing C versions of data processing functions.");
+#if PY_MAJOR_VERSION >= 3
+    m = PyModule_Create(&module_def);
+#else
+    m = Py_InitModule3(MODULE_NAME, module_methods, MODULE_DOC);
+#endif
    if (m == NULL)
-        return;
+        INITERROR;

    PyDateTime_IMPORT;

@@ -460,5 +658,8 @@ initcprocessors(void)
    Py_INCREF(&DecimalResultProcessorType);
    PyModule_AddObject(m, "DecimalResultProcessor",
                       (PyObject *)&DecimalResultProcessorType);
-}

+#if PY_MAJOR_VERSION >= 3
+    return m;
+#endif
+}
@@ -1,6 +1,7 @@
 /*
 resultproxy.c
-Copyright (C) 2010 Gaetan de Menten gdementen@gmail.com
+Copyright (C) 2010-2014 the SQLAlchemy authors and contributors <see AUTHORS file>
+Copyright (C) 2010-2011 Gaetan de Menten gdementen@gmail.com

 This module is part of SQLAlchemy and is released under
 the MIT License: http://www.opensource.org/licenses/mit-license.php
@@ -8,6 +9,9 @@ the MIT License: http://www.opensource.org/licenses/mit-license.php

 #include <Python.h>

+#define MODULE_NAME "cresultproxy"
+#define MODULE_DOC "Module containing C versions of core ResultProxy classes."
+
 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 typedef int Py_ssize_t;
 #define PY_SSIZE_T_MAX INT_MAX
@@ -121,7 +125,7 @@ BaseRowProxy_reduce(PyObject *self)
    if (state == NULL)
        return NULL;

-    module = PyImport_ImportModule("sqlalchemy.engine.base");
+    module = PyImport_ImportModule("sqlalchemy.engine.result");
    if (module == NULL)
        return NULL;

@@ -149,7 +153,11 @@ BaseRowProxy_dealloc(BaseRowProxy *self)
    Py_XDECREF(self->row);
    Py_XDECREF(self->processors);
    Py_XDECREF(self->keymap);
+#if PY_MAJOR_VERSION >= 3
+    Py_TYPE(self)->tp_free((PyObject *)self);
+#else
    self->ob_type->tp_free((PyObject *)self);
+#endif
 }

 static PyObject *
@@ -244,14 +252,21 @@ BaseRowProxy_subscript(BaseRowProxy *self, PyObject *key)
    PyObject *processor, *value, *processed_value;
    PyObject *row, *record, *result, *indexobject;
    PyObject *exc_module, *exception, *cstr_obj;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *bytes;
+#endif
    char *cstr_key;
    long index;
    int key_fallback = 0;
    int tuple_check = 0;

+#if PY_MAJOR_VERSION < 3
    if (PyInt_CheckExact(key)) {
        index = PyInt_AS_LONG(key);
-    } else if (PyLong_CheckExact(key)) {
+    }
+#endif
+
+    if (PyLong_CheckExact(key)) {
        index = PyLong_AsLong(key);
        if ((index == -1) && PyErr_Occurred())
            /* -1 can be either the actual value, or an error flag. */
@@ -304,7 +319,21 @@ BaseRowProxy_subscript(BaseRowProxy *self, PyObject *key)
            cstr_obj = PyObject_Str(key);
            if (cstr_obj == NULL)
                return NULL;
+
+/*
+           FIXME: raise encoding error exception (in both versions below)
+           if the key contains non-ascii chars, instead of an
+           InvalidRequestError without any message like in the
+           python version.
+*/
+#if PY_MAJOR_VERSION >= 3
+            bytes = PyUnicode_AsASCIIString(cstr_obj);
+            if (bytes == NULL)
+                return NULL;
+            cstr_key = PyBytes_AS_STRING(bytes);
+#else
            cstr_key = PyString_AsString(cstr_obj);
+#endif
            if (cstr_key == NULL) {
                Py_DECREF(cstr_obj);
                return NULL;
@@ -317,7 +346,11 @@ BaseRowProxy_subscript(BaseRowProxy *self, PyObject *key)
            return NULL;
        }

+#if PY_MAJOR_VERSION >= 3
+        index = PyLong_AsLong(indexobject);
+#else
        index = PyInt_AsLong(indexobject);
+#endif
        if ((index == -1) && PyErr_Occurred())
            /* -1 can be either the actual value, or an error flag. */
            return NULL;
@@ -356,13 +389,23 @@ BaseRowProxy_subscript(BaseRowProxy *self, PyObject *key)
 static PyObject *
 BaseRowProxy_getitem(PyObject *self, Py_ssize_t i)
 {
-    return BaseRowProxy_subscript((BaseRowProxy*)self, PyInt_FromSsize_t(i));
+    PyObject *index;
+
+#if PY_MAJOR_VERSION >= 3
+    index = PyLong_FromSsize_t(i);
+#else
+    index = PyInt_FromSsize_t(i);
+#endif
+    return BaseRowProxy_subscript((BaseRowProxy*)self, index);
 }

 static PyObject *
 BaseRowProxy_getattro(BaseRowProxy *self, PyObject *name)
 {
    PyObject *tmp;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *err_bytes;
+#endif

    if (!(tmp = PyObject_GenericGetAttr((PyObject *)self, name))) {
        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
@@ -374,11 +417,23 @@ BaseRowProxy_getattro(BaseRowProxy *self, PyObject *name)

    tmp = BaseRowProxy_subscript(self, name);
    if (tmp == NULL && PyErr_ExceptionMatches(PyExc_KeyError)) {
+
+#if PY_MAJOR_VERSION >= 3
+        err_bytes = PyUnicode_AsASCIIString(name);
+        if (err_bytes == NULL)
+            return NULL;
+        PyErr_Format(
+                PyExc_AttributeError,
+                "Could not locate column in row for column '%.200s'",
+                PyBytes_AS_STRING(err_bytes)
+            );
+#else
        PyErr_Format(
                PyExc_AttributeError,
                "Could not locate column in row for column '%.200s'",
                PyString_AsString(name)
            );
+#endif
        return NULL;
    }
    return tmp;
@@ -406,7 +461,7 @@ BaseRowProxy_setparent(BaseRowProxy *self, PyObject *value, void *closure)
        return -1;
    }

-    module = PyImport_ImportModule("sqlalchemy.engine.base");
+    module = PyImport_ImportModule("sqlalchemy.engine.result");
    if (module == NULL)
        return -1;

@@ -564,8 +619,7 @@ static PyMappingMethods BaseRowProxy_as_mapping = {
 };

 static PyTypeObject BaseRowProxyType = {
-    PyObject_HEAD_INIT(NULL)
-    0,                                  /* ob_size */
+    PyVarObject_HEAD_INIT(NULL, 0)
    "sqlalchemy.cresultproxy.BaseRowProxy",          /* tp_name */
    sizeof(BaseRowProxy),               /* tp_basicsize */
    0,                                  /* tp_itemsize */
@@ -605,34 +659,60 @@ static PyTypeObject BaseRowProxyType = {
    0                                   /* tp_new */
 };

-
-#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
-#define PyMODINIT_FUNC void
-#endif
-
-
 static PyMethodDef module_methods[] = {
    {"safe_rowproxy_reconstructor", safe_rowproxy_reconstructor, METH_VARARGS,
     "reconstruct a RowProxy instance from its pickled form."},
    {NULL, NULL, 0, NULL}        /* Sentinel */
 };

+#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
+#define PyMODINIT_FUNC void
+#endif
+
+
+#if PY_MAJOR_VERSION >= 3
+
+static struct PyModuleDef module_def = {
+    PyModuleDef_HEAD_INIT,
+    MODULE_NAME,
+    MODULE_DOC,
+    -1,
+    module_methods
+};
+
+#define INITERROR return NULL
+
+PyObject *
+PyInit_cresultproxy(void)
+
+#else
+
+#define INITERROR return
+
 PyMODINIT_FUNC
 initcresultproxy(void)
+
+#endif
+
 {
    PyObject *m;

    BaseRowProxyType.tp_new = PyType_GenericNew;
    if (PyType_Ready(&BaseRowProxyType) < 0)
-        return;
+        INITERROR;

-    m = Py_InitModule3("cresultproxy", module_methods,
-                       "Module containing C versions of core ResultProxy classes.");
+#if PY_MAJOR_VERSION >= 3
+    m = PyModule_Create(&module_def);
+#else
+    m = Py_InitModule3(MODULE_NAME, module_methods, MODULE_DOC);
+#endif
    if (m == NULL)
-        return;
+        INITERROR;

    Py_INCREF(&BaseRowProxyType);
    PyModule_AddObject(m, "BaseRowProxy", (PyObject *)&BaseRowProxyType);

+#if PY_MAJOR_VERSION >= 3
+    return m;
+#endif
 }
-
@@ -0,0 +1,225 @@
+/*
+utils.c
+Copyright (C) 2012-2014 the SQLAlchemy authors and contributors <see AUTHORS file>
+
+This module is part of SQLAlchemy and is released under
+the MIT License: http://www.opensource.org/licenses/mit-license.php
+*/
+
+#include <Python.h>
+
+#define MODULE_NAME "cutils"
+#define MODULE_DOC "Module containing C versions of utility functions."
+
+/*
+    Given arguments from the calling form *multiparams, **params,
+    return a list of bind parameter structures, usually a list of
+    dictionaries.
+
+    In the case of 'raw' execution which accepts positional parameters,
+    it may be a list of tuples or lists.
+
+ */
+static PyObject *
+distill_params(PyObject *self, PyObject *args)
+{
+	PyObject *multiparams, *params;
+	PyObject *enclosing_list, *double_enclosing_list;
+	PyObject *zero_element, *zero_element_item;
+	Py_ssize_t multiparam_size, zero_element_length;
+
+	if (!PyArg_UnpackTuple(args, "_distill_params", 2, 2, &multiparams, &params)) {
+		return NULL;
+	}
+
+	if (multiparams != Py_None) {
+		multiparam_size = PyTuple_Size(multiparams);
+		if (multiparam_size < 0) {
+			return NULL;
+		}
+	}
+	else {
+		multiparam_size = 0;
+	}
+
+	if (multiparam_size == 0) {
+		if (params != Py_None && PyDict_Size(params) != 0) {
+			enclosing_list = PyList_New(1);
+			if (enclosing_list == NULL) {
+				return NULL;
+			}
+			Py_INCREF(params);
+			if (PyList_SetItem(enclosing_list, 0, params) == -1) {
+				Py_DECREF(params);
+				Py_DECREF(enclosing_list);
+				return NULL;
+			}
+		}
+		else {
+			enclosing_list = PyList_New(0);
+			if (enclosing_list == NULL) {
+				return NULL;
+			}
+		}
+		return enclosing_list;
+	}
+	else if (multiparam_size == 1) {
+		zero_element = PyTuple_GetItem(multiparams, 0);
+		if (PyTuple_Check(zero_element) || PyList_Check(zero_element)) {
+			zero_element_length = PySequence_Length(zero_element);
+
+			if (zero_element_length != 0) {
+				zero_element_item = PySequence_GetItem(zero_element, 0);
+				if (zero_element_item == NULL) {
+					return NULL;
+				}
+			}
+			else {
+				zero_element_item = NULL;
+			}
+
+			if (zero_element_length == 0 ||
+					(
+						PyObject_HasAttrString(zero_element_item, "__iter__") &&
+						!PyObject_HasAttrString(zero_element_item, "strip")
+					)
+				) {
+				/*
+				 * execute(stmt, [{}, {}, {}, ...])
+        		 * execute(stmt, [(), (), (), ...])
+				 */
+				Py_XDECREF(zero_element_item);
+				Py_INCREF(zero_element);
+				return zero_element;
+			}
+			else {
+				/*
+				 * execute(stmt, ("value", "value"))
+				 */
+				Py_XDECREF(zero_element_item);
+				enclosing_list = PyList_New(1);
+				if (enclosing_list == NULL) {
+					return NULL;
+				}
+				Py_INCREF(zero_element);
+				if (PyList_SetItem(enclosing_list, 0, zero_element) == -1) {
+					Py_DECREF(zero_element);
+					Py_DECREF(enclosing_list);
+					return NULL;
+				}
+				return enclosing_list;
+			}
+		}
+		else if (PyObject_HasAttrString(zero_element, "keys")) {
+			/*
+			 * execute(stmt, {"key":"value"})
+			 */
+			enclosing_list = PyList_New(1);
+			if (enclosing_list ==  NULL) {
+				return NULL;
+			}
+			Py_INCREF(zero_element);
+			if (PyList_SetItem(enclosing_list, 0, zero_element) == -1) {
+				Py_DECREF(zero_element);
+				Py_DECREF(enclosing_list);
+				return NULL;
+			}
+			return enclosing_list;
+		} else {
+			enclosing_list = PyList_New(1);
+			if (enclosing_list ==  NULL) {
+				return NULL;
+			}
+			double_enclosing_list = PyList_New(1);
+			if (double_enclosing_list == NULL) {
+				Py_DECREF(enclosing_list);
+				return NULL;
+			}
+			Py_INCREF(zero_element);
+			if (PyList_SetItem(enclosing_list, 0, zero_element) == -1) {
+				Py_DECREF(zero_element);
+				Py_DECREF(enclosing_list);
+				Py_DECREF(double_enclosing_list);
+				return NULL;
+			}
+			if (PyList_SetItem(double_enclosing_list, 0, enclosing_list) == -1) {
+				Py_DECREF(zero_element);
+				Py_DECREF(enclosing_list);
+				Py_DECREF(double_enclosing_list);
+				return NULL;
+			}
+			return double_enclosing_list;
+		}
+	}
+	else {
+		zero_element = PyTuple_GetItem(multiparams, 0);
+		if (PyObject_HasAttrString(zero_element, "__iter__") &&
+				!PyObject_HasAttrString(zero_element, "strip")
+			) {
+			Py_INCREF(multiparams);
+			return multiparams;
+		}
+		else {
+			enclosing_list = PyList_New(1);
+			if (enclosing_list ==  NULL) {
+				return NULL;
+			}
+			Py_INCREF(multiparams);
+			if (PyList_SetItem(enclosing_list, 0, multiparams) == -1) {
+				Py_DECREF(multiparams);
+				Py_DECREF(enclosing_list);
+				return NULL;
+			}
+			return enclosing_list;
+		}
+	}
+}
+
+static PyMethodDef module_methods[] = {
+    {"_distill_params", distill_params, METH_VARARGS,
+     "Distill an execute() parameter structure."},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
+#define PyMODINIT_FUNC void
+#endif
+
+#if PY_MAJOR_VERSION >= 3
+
+static struct PyModuleDef module_def = {
+    PyModuleDef_HEAD_INIT,
+    MODULE_NAME,
+    MODULE_DOC,
+    -1,
+    module_methods
+ };
+#endif
+
+
+#if PY_MAJOR_VERSION >= 3
+PyObject *
+PyInit_cutils(void)
+#else
+PyMODINIT_FUNC
+initcutils(void)
+#endif
+{
+    PyObject *m;
+
+#if PY_MAJOR_VERSION >= 3
+    m = PyModule_Create(&module_def);
+#else
+    m = Py_InitModule3(MODULE_NAME, module_methods, MODULE_DOC);
+#endif
+
+#if PY_MAJOR_VERSION >= 3
+    if (m == NULL)
+        return NULL;
+    return m;
+#else
+    if (m == NULL)
+    	return;
+#endif
+}
+