/* connection.c - the connection 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 "cache.h"

#include "module.h"

#include "connection.h"

#include "statement.h"

#include "cursor.h"

#include "prepare_protocol.h"

#include "util.h"

#include "sqlitecompat.h"

#include "pythread.h"

#define ACTION_FINALIZE 1

#define ACTION_RESET 2

static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level);

static void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len)

{

    /* in older SQLite versions, calling sqlite3_result_error in callbacks

     * triggers a bug in SQLite that leads either to irritating results or

     * segfaults, depending on the SQLite version */

#if SQLITE_VERSION_NUMBER >= 3003003

    sqlite3_result_error(ctx, errmsg, len);

#else

    PyErr_SetString(pysqlite_OperationalError, errmsg);

#endif

}

int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

{

    static char *kwlist[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", NULL, NULL};

    PyObject* database;

    int detect_types = 0;

    PyObject* isolation_level = NULL;

    PyObject* factory = NULL;

    int check_same_thread = 1;

    int cached_statements = 100;

    double timeout = 5.0;

    int rc;

    PyObject* class_attr = NULL;

    PyObject* class_attr_str = NULL;

    int is_apsw_connection = 0;

    PyObject* database_utf8;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|diOiOi", kwlist,

                                     &database, &timeout, &detect_types, &isolation_level, &check_same_thread, &factory, &cached_statements))

    {

        return -1;

    }

    self->begin_statement = NULL;

    self->statement_cache = NULL;

    self->statements = NULL;

    Py_INCREF(Py_None);

    self->row_factory = Py_None;

    Py_INCREF(&PyUnicode_Type);

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

    if (PyString_Check(database) || PyUnicode_Check(database)) {

        if (PyString_Check(database)) {

            database_utf8 = database;

            Py_INCREF(database_utf8);

        } else {

            database_utf8 = PyUnicode_AsUTF8String(database);

            if (!database_utf8) {

                return -1;

            }

        }

        Py_BEGIN_ALLOW_THREADS

        rc = sqlite3_open(PyString_AsString(database_utf8), &self->db);

        Py_END_ALLOW_THREADS

        Py_DECREF(database_utf8);

        if (rc != SQLITE_OK) {

            _pysqlite_seterror(self->db, NULL);

            return -1;

        }

    } else {

        /* Create a pysqlite connection from a APSW connection */

        class_attr = PyObject_GetAttrString(database, "__class__");

        if (class_attr) {

            class_attr_str = PyObject_Str(class_attr);

            if (class_attr_str) {

                if (strcmp(PyString_AsString(class_attr_str), "<type 'apsw.Connection'>") == 0) {

                    /* In the APSW Connection object, the first entry after

                     * PyObject_HEAD is the sqlite3* we want to get hold of.

                     * Luckily, this is the same layout as we have in our

                     * pysqlite_Connection */

                    self->db = ((pysqlite_Connection*)database)->db;

                    Py_INCREF(database);

                    self->apsw_connection = database;

                    is_apsw_connection = 1;

                }

            }

        }

        Py_XDECREF(class_attr_str);

        Py_XDECREF(class_attr);

        if (!is_apsw_connection) {

            PyErr_SetString(PyExc_ValueError, "database parameter must be string or APSW Connection object");

            return -1;

        }

    }

    if (!isolation_level) {

        isolation_level = PyString_FromString("");

        if (!isolation_level) {

            return -1;

        }

    } else {

        Py_INCREF(isolation_level);

    }

    self->isolation_level = NULL;

    pysqlite_connection_set_isolation_level(self, isolation_level);

    Py_DECREF(isolation_level);

    self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements);

    if (PyErr_Occurred()) {

        return -1;

    }

    self->statements = PyList_New(0);

    if (!self->statements) {

        return -1;

    }

    self->created_statements = 0;

    /* By default, the Cache class INCREFs the factory in its initializer, and

     * decrefs it in its deallocator method. Since this would create a circular

     * reference here, we're breaking it by decrementing self, and telling the

     * cache class to not decref the factory (self) in its deallocator.

     */

    self->statement_cache->decref_factory = 0;

    Py_DECREF(self);

    self->inTransaction = 0;

    self->detect_types = detect_types;

    self->timeout = timeout;

    (void)sqlite3_busy_timeout(self->db, (int)(timeout*1000));

    self->thread_ident = PyThread_get_thread_ident();

    self->check_same_thread = check_same_thread;

    self->function_pinboard = PyDict_New();

    if (!self->function_pinboard) {

        return -1;

    }

    self->collations = PyDict_New();

    if (!self->collations) {

        return -1;

    }

    self->Warning               = pysqlite_Warning;

    self->Error                 = pysqlite_Error;

    self->InterfaceError        = pysqlite_InterfaceError;

    self->DatabaseError         = pysqlite_DatabaseError;

    self->DataError             = pysqlite_DataError;

    self->OperationalError      = pysqlite_OperationalError;

    self->IntegrityError        = pysqlite_IntegrityError;

    self->InternalError         = pysqlite_InternalError;

    self->ProgrammingError      = pysqlite_ProgrammingError;

    self->NotSupportedError     = pysqlite_NotSupportedError;

    return 0;

}

/* Empty the entire statement cache of this connection */

void pysqlite_flush_statement_cache(pysqlite_Connection* self)

{

    pysqlite_Node* node;

    pysqlite_Statement* statement;

    node = self->statement_cache->first;

    while (node) {

        statement = (pysqlite_Statement*)(node->data);

        (void)pysqlite_statement_finalize(statement);

        node = node->next;

    }

    Py_DECREF(self->statement_cache);

    self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "O", self);

    Py_DECREF(self);

    self->statement_cache->decref_factory = 0;

}

/* action in (ACTION_RESET, ACTION_FINALIZE) */

void pysqlite_do_all_statements(pysqlite_Connection* self, int action)

{

    int i;

    PyObject* weakref;

    PyObject* statement;

    for (i = 0; i < PyList_Size(self->statements); i++) {

        weakref = PyList_GetItem(self->statements, i);

        statement = PyWeakref_GetObject(weakref);

        if (statement != Py_None) {

            if (action == ACTION_RESET) {

                (void)pysqlite_statement_reset((pysqlite_Statement*)statement);

            } else {

                (void)pysqlite_statement_finalize((pysqlite_Statement*)statement);

            }

        }

    }

}

void pysqlite_connection_dealloc(pysqlite_Connection* self)

{

    PyObject* ret = NULL;

    Py_XDECREF(self->statement_cache);

    /* Clean up if user has not called .close() explicitly. */

    if (self->db) {

        Py_BEGIN_ALLOW_THREADS

        sqlite3_close(self->db);

        Py_END_ALLOW_THREADS

    } else if (self->apsw_connection) {

        ret = PyObject_CallMethod(self->apsw_connection, "close", "");

        Py_XDECREF(ret);

        Py_XDECREF(self->apsw_connection);

    }

    if (self->begin_statement) {

        PyMem_Free(self->begin_statement);

    }

    Py_XDECREF(self->isolation_level);

    Py_XDECREF(self->function_pinboard);

    Py_XDECREF(self->row_factory);

    Py_XDECREF(self->text_factory);

    Py_XDECREF(self->collations);

    Py_XDECREF(self->statements);

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

}

PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

{

    static char *kwlist[] = {"factory", NULL, NULL};

    PyObject* factory = NULL;

    PyObject* cursor;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist,

                                     &factory)) {

        return NULL;

    }

    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

        return NULL;

    }

    if (factory == NULL) {

        factory = (PyObject*)&pysqlite_CursorType;

    }

    cursor = PyObject_CallFunction(factory, "O", self);

    if (cursor && self->row_factory != Py_None) {

        Py_XDECREF(((pysqlite_Cursor*)cursor)->row_factory);

        Py_INCREF(self->row_factory);

        ((pysqlite_Cursor*)cursor)->row_factory = self->row_factory;

    }

    return cursor;

}

PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args)

{

    PyObject* ret;

    int rc;

    if (!pysqlite_check_thread(self)) {

        return NULL;

    }

    pysqlite_do_all_statements(self, ACTION_FINALIZE);

    if (self->db) {

        if (self->apsw_connection) {

            ret = PyObject_CallMethod(self->apsw_connection, "close", "");

            Py_XDECREF(ret);

            Py_XDECREF(self->apsw_connection);

            self->apsw_connection = NULL;

            self->db = NULL;

        } else {

            Py_BEGIN_ALLOW_THREADS

            rc = sqlite3_close(self->db);

            Py_END_ALLOW_THREADS

            if (rc != SQLITE_OK) {

                _pysqlite_seterror(self->db, NULL);

                return NULL;

            } else {

                self->db = NULL;

            }

        }

    }

    Py_INCREF(Py_None);

    return Py_None;

}

/*

 * Checks if a connection object is usable (i. e. not closed).

 *

 * 0 => error; 1 => ok

 */

int pysqlite_check_connection(pysqlite_Connection* con)

{

    if (!con->db) {

        PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database.");

        return 0;

    } else {

        return 1;

    }

}

PyObject* _pysqlite_connection_begin(pysqlite_Connection* self)

{

    int rc;

    const char* tail;

    sqlite3_stmt* statement;

    Py_BEGIN_ALLOW_THREADS

    rc = sqlite3_prepare(self->db, self->begin_statement, -1, &statement, &tail);

    Py_END_ALLOW_THREADS

    if (rc != SQLITE_OK) {

        _pysqlite_seterror(self->db, statement);

        goto error;

    }

    rc = pysqlite_step(statement, self);

    if (rc == SQLITE_DONE) {

        self->inTransaction = 1;

    } else {

        _pysqlite_seterror(self->db, statement);

    }

    Py_BEGIN_ALLOW_THREADS

    rc = sqlite3_finalize(statement);

    Py_END_ALLOW_THREADS

    if (rc != SQLITE_OK && !PyErr_Occurred()) {

        _pysqlite_seterror(self->db, NULL);

    }

error:

    if (PyErr_Occurred()) {

        return NULL;

    } else {

        Py_INCREF(Py_None);

        return Py_None;

    }

}

PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args)

{

    int rc;

    const char* tail;

    sqlite3_stmt* statement;

    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

        return NULL;

    }

    if (self->inTransaction) {

        Py_BEGIN_ALLOW_THREADS

        rc = sqlite3_prepare(self->db, "COMMIT", -1, &statement, &tail);

        Py_END_ALLOW_THREADS

        if (rc != SQLITE_OK) {

            _pysqlite_seterror(self->db, NULL);

            goto error;

        }

        rc = pysqlite_step(statement, self);

        if (rc == SQLITE_DONE) {

            self->inTransaction = 0;

        } else {

            _pysqlite_seterror(self->db, statement);

        }

        Py_BEGIN_ALLOW_THREADS

        rc = sqlite3_finalize(statement);

        Py_END_ALLOW_THREADS

        if (rc != SQLITE_OK && !PyErr_Occurred()) {

            _pysqlite_seterror(self->db, NULL);

        }

    }

error:

    if (PyErr_Occurred()) {

        return NULL;

    } else {

        Py_INCREF(Py_None);

        return Py_None;

    }

}

PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args)

{

    int rc;

    const char* tail;

    sqlite3_stmt* statement;

    if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

        return NULL;

    }

    if (self->inTransaction) {

        pysqlite_do_all_statements(self, ACTION_RESET);

        Py_BEGIN_ALLOW_THREADS

        rc = sqlite3_prepare(self->db, "ROLLBACK", -1, &statement, &tail);

        Py_END_ALLOW_THREADS

        if (rc != SQLITE_OK) {

            _pysqlite_seterror(self->db, NULL);

            goto error;

        }

        rc = pysqlite_step(statement, self);

        if (rc == SQLITE_DONE) {

            self->inTransaction = 0;

        } else {

            _pysqlite_seterror(self->db, statement);

        }

        Py_BEGIN_ALLOW_THREADS

        rc = sqlite3_finalize(statement);

        Py_END_ALLOW_THREADS

        if (rc != SQLITE_OK && !PyErr_Occurred()) {

            _pysqlite_seterror(self->db, NULL);

        }

    }

error:

    if (PyErr_Occurred()) {

        return NULL;

    } else {

        Py_INCREF(Py_None);

        return Py_None;

    }

}

void _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)

{

    long longval;

    const char* buffer;

    Py_ssize_t buflen;

    PyObject* stringval;

    if ((!py_val) || PyErr_Occurred()) {

        sqlite3_result_null(context);

    } else if (py_val == Py_None) {

        sqlite3_result_null(context);

    } else if (PyInt_Check(py_val)) {

        longval = PyInt_AsLong(py_val);

        sqlite3_result_int64(context, (PY_LONG_LONG)longval);

    } else if (PyFloat_Check(py_val)) {

        sqlite3_result_double(context, PyFloat_AsDouble(py_val));

    } else if (PyBuffer_Check(py_val)) {

        if (PyObject_AsCharBuffer(py_val, &buffer, &buflen) != 0) {

            PyErr_SetString(PyExc_ValueError, "could not convert BLOB to buffer");

        } else {

            sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT);

        }

    } else if (PyString_Check(py_val)) {

        sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT);

    } else if (PyUnicode_Check(py_val)) {

        stringval = PyUnicode_AsUTF8String(py_val);

        if (stringval) {

            sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT);

            Py_DECREF(stringval);

        }

    } else {

        /* TODO: raise error */

    }

}

PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv)

{

    PyObject* args;

    int i;

    sqlite3_value* cur_value;

    PyObject* cur_py_value;

    const char* val_str;

    PY_LONG_LONG val_int;

    Py_ssize_t buflen;

    void* raw_buffer;

    args = PyTuple_New(argc);

    if (!args) {

        return NULL;

    }