/* cursor.c - the cursor type

 *

 * Copyright (C) 2004-2007 Gerhard Häring <gh@ghaering.de>

 *

 * This file is part of pysqlite.

 *

 * This software is provided 'as-is', without any express or implied

 * warranty.  In no event will the authors be held liable for any damages

 * arising from the use of this software.

 *

 * Permission is granted to anyone to use this software for any purpose,

 * including commercial applications, and to alter it and redistribute it

 * freely, subject to the following restrictions:

 *

 * 1. The origin of this software must not be misrepresented; you must not

 *    claim that you wrote the original software. If you use this software

 *    in a product, an acknowledgment in the product documentation would be

 *    appreciated but is not required.

 * 2. Altered source versions must be plainly marked as such, and must not be

 *    misrepresented as being the original software.

 * 3. This notice may not be removed or altered from any source distribution.

 */

#include "cursor.h"

#include "module.h"

#include "util.h"

#include "sqlitecompat.h"

/* used to decide wether to call PyInt_FromLong or PyLong_FromLongLong */

#ifndef INT32_MIN

#define INT32_MIN (-2147483647 - 1)

#endif

#ifndef INT32_MAX

#define INT32_MAX 2147483647

#endif

PyObject* pysqlite_cursor_iternext(pysqlite_Cursor* self);

static pysqlite_StatementKind detect_statement_type(char* statement)

{

    char buf[20];

    char* src;

    char* dst;

    src = statement;

    /* skip over whitepace */

    while (*src == '\r' || *src == '\n' || *src == ' ' || *src == '\t') {

        src++;

    }

    if (*src == 0)

        return STATEMENT_INVALID;

    dst = buf;

    *dst = 0;

    while (isalpha(*src) && dst - buf < sizeof(buf) - 2) {

        *dst++ = tolower(*src++);

    }

    *dst = 0;

    if (!strcmp(buf, "select")) {

        return STATEMENT_SELECT;

    } else if (!strcmp(buf, "insert")) {

        return STATEMENT_INSERT;

    } else if (!strcmp(buf, "update")) {

        return STATEMENT_UPDATE;

    } else if (!strcmp(buf, "delete")) {

        return STATEMENT_DELETE;

    } else if (!strcmp(buf, "replace")) {

        return STATEMENT_REPLACE;

    } else {

        return STATEMENT_OTHER;

    }

}

int pysqlite_cursor_init(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs)

{

    pysqlite_Connection* connection;

    if (!PyArg_ParseTuple(args, "O!", &pysqlite_ConnectionType, &connection))

    {

        return -1;

    }

    Py_INCREF(connection);

    self->connection = connection;

    self->statement = NULL;

    self->next_row = NULL;

    self->row_cast_map = PyList_New(0);

    if (!self->row_cast_map) {

        return -1;

    }

    Py_INCREF(Py_None);

    self->description = Py_None;

    Py_INCREF(Py_None);

    self->lastrowid= Py_None;

    self->arraysize = 1;

    self->rowcount = -1L;

    Py_INCREF(Py_None);

    self->row_factory = Py_None;

    if (!pysqlite_check_thread(self->connection)) {

        return -1;

    }

    return 0;

}

void pysqlite_cursor_dealloc(pysqlite_Cursor* self)

{

    int rc;

    /* Reset the statement if the user has not closed the cursor */

    if (self->statement) {

        rc = pysqlite_statement_reset(self->statement);

        Py_DECREF(self->statement);

    }

    Py_XDECREF(self->connection);

    Py_XDECREF(self->row_cast_map);

    Py_XDECREF(self->description);

    Py_XDECREF(self->lastrowid);

    Py_XDECREF(self->row_factory);

    Py_XDECREF(self->next_row);

    Py_TYPE(self)->tp_free((PyObject*)self);

}

PyObject* _pysqlite_get_converter(PyObject* key)

{

    PyObject* upcase_key;

    PyObject* retval;

    upcase_key = PyObject_CallMethod(key, "upper", "");

    if (!upcase_key) {

        return NULL;

    }

    retval = PyDict_GetItem(converters, upcase_key);

    Py_DECREF(upcase_key);

    return retval;

}

int pysqlite_build_row_cast_map(pysqlite_Cursor* self)

{

    int i;

    const char* type_start = (const char*)-1;

    const char* pos;

    const char* colname;

    const char* decltype;

    PyObject* py_decltype;

    PyObject* converter;

    PyObject* key;

    if (!self->connection->detect_types) {

        return 0;

    }

    Py_XDECREF(self->row_cast_map);

    self->row_cast_map = PyList_New(0);

    for (i = 0; i < sqlite3_column_count(self->statement->st); i++) {

        converter = NULL;

        if (self->connection->detect_types & PARSE_COLNAMES) {

            colname = sqlite3_column_name(self->statement->st, i);

            if (colname) {

                for (pos = colname; *pos != 0; pos++) {

                    if (*pos == '[') {

                        type_start = pos + 1;

                    } else if (*pos == ']' && type_start != (const char*)-1) {

                        key = PyString_FromStringAndSize(type_start, pos - type_start);

                        if (!key) {

                            /* creating a string failed, but it is too complicated

                             * to propagate the error here, we just assume there is

                             * no converter and proceed */

                            break;

                        }

                        converter = _pysqlite_get_converter(key);

                        Py_DECREF(key);

                        break;

                    }

                }

            }

        }

        if (!converter && self->connection->detect_types & PARSE_DECLTYPES) {

            decltype = sqlite3_column_decltype(self->statement->st, i);

            if (decltype) {

                for (pos = decltype;;pos++) {

                    /* Converter names are split at '(' and blanks.

                     * This allows 'INTEGER NOT NULL' to be treated as 'INTEGER' and

                     * 'NUMBER(10)' to be treated as 'NUMBER', for example.

                     * In other words, it will work as people expect it to work.*/

                    if (*pos == ' ' || *pos == '(' || *pos == 0) {

                        py_decltype = PyString_FromStringAndSize(decltype, pos - decltype);

                        if (!py_decltype) {

                            return -1;

                        }

                        break;

                    }

                }

                converter = _pysqlite_get_converter(py_decltype);

                Py_DECREF(py_decltype);

            }

        }

        if (!converter) {

            converter = Py_None;

        }

        if (PyList_Append(self->row_cast_map, converter) != 0) {

            if (converter != Py_None) {

                Py_DECREF(converter);

            }

            Py_XDECREF(self->row_cast_map);

            self->row_cast_map = NULL;

            return -1;

        }

    }

    return 0;

}

PyObject* _pysqlite_build_column_name(const char* colname)

{

    const char* pos;

    if (!colname) {

        Py_INCREF(Py_None);

        return Py_None;

    }

    for (pos = colname;; pos++) {

        if (*pos == 0 || *pos == '[') {

            if ((*pos == '[') && (pos > colname) && (*(pos-1) == ' ')) {

                pos--;

            }

            return PyString_FromStringAndSize(colname, pos - colname);

        }

    }

}

PyObject* pysqlite_unicode_from_string(const char* val_str, int optimize)

{

    const char* check;

    int is_ascii = 0;

    if (optimize) {

        is_ascii = 1;

        check = val_str;

        while (*check) {

            if (*check & 0x80) {

                is_ascii = 0;

                break;

            }

            check++;

        }

    }

    if (is_ascii) {

        return PyString_FromString(val_str);

    } else {

        return PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);

    }

}

/*

 * Returns a row from the currently active SQLite statement

 *

 * Precondidition:

 * - sqlite3_step() has been called before and it returned SQLITE_ROW.

 */

PyObject* _pysqlite_fetch_one_row(pysqlite_Cursor* self)

{

    int i, numcols;

    PyObject* row;

    PyObject* item = NULL;

    int coltype;

    PY_LONG_LONG intval;

    PyObject* converter;

    PyObject* converted;

    Py_ssize_t nbytes;

    PyObject* buffer;

    void* raw_buffer;

    const char* val_str;

    char buf[200];

    const char* colname;

    Py_BEGIN_ALLOW_THREADS

    numcols = sqlite3_data_count(self->statement->st);

    Py_END_ALLOW_THREADS

    row = PyTuple_New(numcols);

    if (!row) {

        return NULL;

    }

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

        if (self->connection->detect_types) {

            converter = PyList_GetItem(self->row_cast_map, i);

            if (!converter) {

                converter = Py_None;

            }

        } else {

            converter = Py_None;

        }

        if (converter != Py_None) {

            nbytes = sqlite3_column_bytes(self->statement->st, i);

            val_str = (const char*)sqlite3_column_blob(self->statement->st, i);

            if (!val_str) {

                Py_INCREF(Py_None);

                converted = Py_None;

            } else {

                item = PyString_FromStringAndSize(val_str, nbytes);

                if (!item) {

                    return NULL;

                }

                converted = PyObject_CallFunction(converter, "O", item);

                Py_DECREF(item);

                if (!converted) {

                    break;

                }

            }

        } else {

            Py_BEGIN_ALLOW_THREADS

            coltype = sqlite3_column_type(self->statement->st, i);

            Py_END_ALLOW_THREADS

            if (coltype == SQLITE_NULL) {

                Py_INCREF(Py_None);

                converted = Py_None;

            } else if (coltype == SQLITE_INTEGER) {

                intval = sqlite3_column_int64(self->statement->st, i);

                if (intval < INT32_MIN || intval > INT32_MAX) {

                    converted = PyLong_FromLongLong(intval);

                } else {

                    converted = PyInt_FromLong((long)intval);

                }

            } else if (coltype == SQLITE_FLOAT) {

                converted = PyFloat_FromDouble(sqlite3_column_double(self->statement->st, i));

            } else if (coltype == SQLITE_TEXT) {

                val_str = (const char*)sqlite3_column_text(self->statement->st, i);

                if ((self->connection->text_factory == (PyObject*)&PyUnicode_Type)

                    || (self->connection->text_factory == pysqlite_OptimizedUnicode)) {

                    converted = pysqlite_unicode_from_string(val_str,

                        self->connection->text_factory == pysqlite_OptimizedUnicode ? 1 : 0);

                    if (!converted) {

                        colname = sqlite3_column_name(self->statement->st, i);

                        if (!colname) {

                            colname = "<unknown column name>";

                        }

                        PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'",

                                     colname , val_str);

                        PyErr_SetString(pysqlite_OperationalError, buf);

                    }

                } else if (self->connection->text_factory == (PyObject*)&PyString_Type) {

                    converted = PyString_FromString(val_str);

                } else {

                    converted = PyObject_CallFunction(self->connection->text_factory, "s", val_str);

                }

            } else {

                /* coltype == SQLITE_BLOB */

                nbytes = sqlite3_column_bytes(self->statement->st, i);

                buffer = PyBuffer_New(nbytes);

                if (!buffer) {

                    break;

                }

                if (PyObject_AsWriteBuffer(buffer, &raw_buffer, &nbytes)) {

                    break;

                }

                memcpy(raw_buffer, sqlite3_column_blob(self->statement->st, i), nbytes);

                converted = buffer;

            }

        }

        if (converted) {

            PyTuple_SetItem(row, i, converted);

        } else {

            Py_INCREF(Py_None);

            PyTuple_SetItem(row, i, Py_None);

        }

    }

    if (PyErr_Occurred()) {

        Py_DECREF(row);

        row = NULL;

    }

    return row;

}

PyObject* _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)

{

    PyObject* operation;

    PyObject* operation_bytestr = NULL;

    char* operation_cstr;

    PyObject* parameters_list = NULL;

    PyObject* parameters_iter = NULL;

    PyObject* parameters = NULL;

    int i;

    int rc;

    PyObject* func_args;

    PyObject* result;

    int numcols;

    PY_LONG_LONG lastrowid;

    int statement_type;

    PyObject* descriptor;

    PyObject* second_argument = NULL;

    int allow_8bit_chars;

    if (!pysqlite_check_thread(self->connection) || !pysqlite_check_connection(self->connection)) {

        return NULL;

    }

    /* Make shooting yourself in the foot with not utf-8 decodable 8-bit-strings harder */

    allow_8bit_chars = ((self->connection->text_factory != (PyObject*)&PyUnicode_Type) &&

        (self->connection->text_factory != (PyObject*)&PyUnicode_Type && pysqlite_OptimizedUnicode));

    Py_XDECREF(self->next_row);

    self->next_row = NULL;

    if (multiple) {

        /* executemany() */

        if (!PyArg_ParseTuple(args, "OO", &operation, &second_argument)) {

            return NULL;

        }

        if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {

            PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");

            return NULL;

        }

        if (PyIter_Check(second_argument)) {

            /* iterator */

            Py_INCREF(second_argument);

            parameters_iter = second_argument;

        } else {

            /* sequence */

            parameters_iter = PyObject_GetIter(second_argument);

            if (!parameters_iter) {

                return NULL;

            }

        }

    } else {

        /* execute() */

        if (!PyArg_ParseTuple(args, "O|O", &operation, &second_argument)) {

            return NULL;

        }

        if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {

            PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");

            return NULL;

        }

        parameters_list = PyList_New(0);

        if (!parameters_list) {

            return NULL;

        }

        if (second_argument == NULL) {

            second_argument = PyTuple_New(0);

            if (!second_argument) {

                goto error;

            }

        } else {

            Py_INCREF(second_argument);

        }

        if (PyList_Append(parameters_list, second_argument) != 0) {

            Py_DECREF(second_argument);

            goto error;

        }

        Py_DECREF(second_argument);

        parameters_iter = PyObject_GetIter(parameters_list);

        if (!parameters_iter) {

            goto error;

        }

    }

    if (self->statement != NULL) {

        /* There is an active statement */

        rc = pysqlite_statement_reset(self->statement);

    }

    if (PyString_Check(operation)) {

        operation_cstr = PyString_AsString(operation);

    } else {

        operation_bytestr = PyUnicode_AsUTF8String(operation);

        if (!operation_bytestr) {

            goto error;

        }

        operation_cstr = PyString_AsString(operation_bytestr);

    }

    /* reset description and rowcount */

    Py_DECREF(self->description);

    Py_INCREF(Py_None);

    self->description = Py_None;

    self->rowcount = -1L;

    func_args = PyTuple_New(1);

    if (!func_args) {

        goto error;

    }

    Py_INCREF(operation);

    if (PyTuple_SetItem(func_args, 0, operation) != 0) {

        goto error;

    }

    if (self->statement) {

        (void)pysqlite_statement_reset(self->statement);