mirror of
https://github.com/python/cpython.git
synced 2025-07-25 04:04:13 +00:00

svn+ssh://pythondev@svn.python.org/python/trunk ........ r53304 | vinay.sajip | 2007-01-09 15:50:28 +0100 (Tue, 09 Jan 2007) | 1 line Bug #1627575: Added _open() method to FileHandler which can be used to reopen files. The FileHandler instance now saves the encoding (which can be None) in an attribute called "encoding". ........ r53305 | vinay.sajip | 2007-01-09 15:51:36 +0100 (Tue, 09 Jan 2007) | 1 line Added entry about addition of _open() method to logging.FileHandler. ........ r53306 | vinay.sajip | 2007-01-09 15:54:56 +0100 (Tue, 09 Jan 2007) | 1 line Added a docstring ........ r53316 | thomas.heller | 2007-01-09 20:19:33 +0100 (Tue, 09 Jan 2007) | 4 lines Verify the sizes of the basic ctypes data types against the struct module. Will backport to release25-maint. ........ r53340 | gustavo.niemeyer | 2007-01-10 17:13:40 +0100 (Wed, 10 Jan 2007) | 3 lines Mention in the int() docstring that a base zero has meaning, as stated in http://docs.python.org/lib/built-in-funcs.html as well. ........ r53341 | gustavo.niemeyer | 2007-01-10 17:15:48 +0100 (Wed, 10 Jan 2007) | 2 lines Minor change in int() docstring for proper spacing. ........ r53358 | thomas.heller | 2007-01-10 21:12:13 +0100 (Wed, 10 Jan 2007) | 1 line Change the ctypes version number to "1.1.0". ........ r53361 | thomas.heller | 2007-01-10 21:51:19 +0100 (Wed, 10 Jan 2007) | 1 line Must change the version number in the _ctypes extension as well. ........ r53362 | guido.van.rossum | 2007-01-11 00:12:56 +0100 (Thu, 11 Jan 2007) | 3 lines Fix the signature of log_error(). (A subclass that did the right thing was getting complaints from pychecker.) ........ r53370 | matthias.klose | 2007-01-11 11:26:31 +0100 (Thu, 11 Jan 2007) | 2 lines - Make the documentation match the code and the docstring ........ r53375 | matthias.klose | 2007-01-11 12:44:04 +0100 (Thu, 11 Jan 2007) | 2 lines - idle: Honor the "Cancel" action in the save dialog (Debian bug #299092). ........ r53381 | raymond.hettinger | 2007-01-11 19:22:55 +0100 (Thu, 11 Jan 2007) | 1 line SF #1486663 -- Allow keyword args in subclasses of set() and frozenset(). ........ r53388 | thomas.heller | 2007-01-11 22:18:56 +0100 (Thu, 11 Jan 2007) | 4 lines Fixes for 64-bit Windows: In ctypes.wintypes, correct the definitions of HANDLE, WPARAM, LPARAM data types. Make parameterless foreign function calls work. ........ r53390 | thomas.heller | 2007-01-11 22:23:12 +0100 (Thu, 11 Jan 2007) | 2 lines Correct the comments: the code is right. ........ r53393 | brett.cannon | 2007-01-12 08:27:52 +0100 (Fri, 12 Jan 2007) | 3 lines Fix error where the end of a funcdesc environment was accidentally moved too far down. ........ r53397 | anthony.baxter | 2007-01-12 10:35:56 +0100 (Fri, 12 Jan 2007) | 3 lines add parsetok.h as a dependency - previously, changing this file doesn't cause the right files to be rebuilt. ........ r53401 | thomas.heller | 2007-01-12 21:08:19 +0100 (Fri, 12 Jan 2007) | 3 lines Avoid warnings in the test suite because ctypes.wintypes cannot be imported on non-windows systems. ........ r53402 | thomas.heller | 2007-01-12 21:17:34 +0100 (Fri, 12 Jan 2007) | 6 lines patch #1610795: BSD version of ctypes.util.find_library, by Martin Kammerhofer. release25-maint backport candidate, but the release manager has to decide. ........ r53403 | thomas.heller | 2007-01-12 21:21:53 +0100 (Fri, 12 Jan 2007) | 3 lines patch #1610795: BSD version of ctypes.util.find_library, by Martin Kammerhofer. ........ r53406 | brett.cannon | 2007-01-13 01:29:49 +0100 (Sat, 13 Jan 2007) | 2 lines Deprecate the sets module. ........ r53407 | georg.brandl | 2007-01-13 13:31:51 +0100 (Sat, 13 Jan 2007) | 3 lines Fix typo. ........ r53409 | marc-andre.lemburg | 2007-01-13 22:00:08 +0100 (Sat, 13 Jan 2007) | 16 lines Bump version number and change copyright year. Add new API linux_distribution() which supports reading the full distribution name and also knows how to parse LSB-style release files. Redirect the old dist() API to the new API (using the short distribution name taken from the release file filename). Add branch and revision to _sys_version(). Add work-around for Cygwin to libc_ver(). Add support for IronPython (thanks for Anthony Baxter) and make Jython support more robust. ........ r53410 | neal.norwitz | 2007-01-13 22:22:37 +0100 (Sat, 13 Jan 2007) | 1 line Fix grammar in docstrings ........ r53411 | marc-andre.lemburg | 2007-01-13 23:32:21 +0100 (Sat, 13 Jan 2007) | 9 lines Add parameter sys_version to _sys_version(). Change the cache for _sys_version() to take the parameter into account. Add support for parsing the IronPython 1.0.1 sys.version value - even though it still returns '1.0.0'; the version string no longer includes the patch level. ........ r53412 | peter.astrand | 2007-01-13 23:35:35 +0100 (Sat, 13 Jan 2007) | 1 line Fix for bug #1634343: allow specifying empty arguments on Windows ........ r53414 | marc-andre.lemburg | 2007-01-13 23:59:36 +0100 (Sat, 13 Jan 2007) | 14 lines Add Python implementation to the machine details. Pretty-print the Python version used for running PyBench. Let the user know when calibration has finished. [ 1563844 ] pybench support for IronPython: Simplify Unicode version detection. Make garbage collection and check interval settings optional if the Python implementation doesn't support thess (e.g. IronPython). ........ r53415 | marc-andre.lemburg | 2007-01-14 00:13:54 +0100 (Sun, 14 Jan 2007) | 5 lines Use defaults if sys.executable isn't set (e.g. on Jython). This change allows running PyBench under Jython. ........ r53416 | marc-andre.lemburg | 2007-01-14 00:15:33 +0100 (Sun, 14 Jan 2007) | 3 lines Jython doesn't have sys.setcheckinterval() - ignore it in that case. ........ r53420 | gerhard.haering | 2007-01-14 02:43:50 +0100 (Sun, 14 Jan 2007) | 29 lines Merged changes from standalone version 2.3.3. This should probably all be merged into the 2.5 maintenance branch: - self->statement was not checked while fetching data, which could lead to crashes if you used the pysqlite API in unusual ways. Closing the cursor and continuing to fetch data was enough. - Converters are stored in a converters dictionary. The converter name is uppercased first. The old upper-casing algorithm was wrong and was replaced by a simple call to the Python string's upper() method instead. -Applied patch by Glyph Lefkowitz that fixes the problem with subsequent SQLITE_SCHEMA errors. - Improvement to the row type: rows can now be iterated over and have a keys() method. This improves compatibility with both tuple and dict a lot. - A bugfix for the subsecond resolution in timestamps. - Corrected the way the flags PARSE_DECLTYPES and PARSE_COLNAMES are checked for. Now they work as documented. - gcc on Linux sucks. It exports all symbols by default in shared libraries, so if symbols are not unique it can lead to problems with symbol lookup. pysqlite used to crash under Apache when mod_cache was enabled because both modules had the symbol cache_init. I fixed this by applying the prefix pysqlite_ almost everywhere. Sigh. ........ r53423 | guido.van.rossum | 2007-01-14 04:46:33 +0100 (Sun, 14 Jan 2007) | 2 lines Remove a dependency of this test on $COLUMNS. ........ r53425 | ka-ping.yee | 2007-01-14 05:25:15 +0100 (Sun, 14 Jan 2007) | 3 lines Handle old-style instances more gracefully (display documentation on the relevant class instead of documentation on <type 'instance'>). ........ r53440 | vinay.sajip | 2007-01-14 22:49:59 +0100 (Sun, 14 Jan 2007) | 1 line Added WatchedFileHandler (based on SF patch #1598415) ........ r53441 | vinay.sajip | 2007-01-14 22:50:50 +0100 (Sun, 14 Jan 2007) | 1 line Added documentation for WatchedFileHandler (based on SF patch #1598415) ........ r53442 | guido.van.rossum | 2007-01-15 01:02:35 +0100 (Mon, 15 Jan 2007) | 2 lines Doc patch matching r53434 (htonl etc. now always take/return positive ints). ........
1255 lines
37 KiB
C
1255 lines
37 KiB
C
/* connection.c - the connection type
|
|
*
|
|
* Copyright (C) 2004-2006 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"
|
|
|
|
static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level);
|
|
|
|
|
|
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};
|
|
|
|
char* 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;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|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;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
rc = sqlite3_open(database, &self->db);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != SQLITE_OK) {
|
|
_pysqlite_seterror(self->db);
|
|
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;
|
|
}
|
|
|
|
void pysqlite_reset_all_statements(pysqlite_Connection* self)
|
|
{
|
|
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) {
|
|
(void)pysqlite_statement_reset((pysqlite_Statement*)statement);
|
|
}
|
|
}
|
|
}
|
|
|
|
void pysqlite_connection_dealloc(pysqlite_Connection* self)
|
|
{
|
|
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
|
|
}
|
|
|
|
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)
|
|
{
|
|
int rc;
|
|
|
|
if (!pysqlite_check_thread(self)) {
|
|
return NULL;
|
|
}
|
|
|
|
pysqlite_flush_statement_cache(self);
|
|
|
|
if (self->db) {
|
|
Py_BEGIN_ALLOW_THREADS
|
|
rc = sqlite3_close(self->db);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != SQLITE_OK) {
|
|
_pysqlite_seterror(self->db);
|
|
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);
|
|
goto error;
|
|
}
|
|
|
|
rc = _sqlite_step_with_busyhandler(statement, self);
|
|
if (rc == SQLITE_DONE) {
|
|
self->inTransaction = 1;
|
|
} else {
|
|
_pysqlite_seterror(self->db);
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
rc = sqlite3_finalize(statement);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != SQLITE_OK && !PyErr_Occurred()) {
|
|
_pysqlite_seterror(self->db);
|
|
}
|
|
|
|
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);
|
|
goto error;
|
|
}
|
|
|
|
rc = _sqlite_step_with_busyhandler(statement, self);
|
|
if (rc == SQLITE_DONE) {
|
|
self->inTransaction = 0;
|
|
} else {
|
|
_pysqlite_seterror(self->db);
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
rc = sqlite3_finalize(statement);
|
|
Py_END_ALLOW_THREADS
|
|
if (rc != SQLITE_OK && !PyErr_Occurred()) {
|
|
_pysqlite_seterror(self->db);
|
|
}
|
|
|
|
}
|
|
|
|
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_reset_all_statements(self);
|
|
|
|
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);
|
|
goto error;
|
|
}
|
|
|
|
rc = _sqlite_step_with_busyhandler(statement, self);
|
|
if (rc == SQLITE_DONE) {
|
|
self->inTransaction = 0;
|
|
} else {
|
|
_pysqlite_seterror(self->db);
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
rc = sqlite3_finalize(statement);
|
|
Py_END_ALLOW_THREADS
|
|
if (rc != SQLITE_OK && !PyErr_Occurred()) {
|
|
_pysqlite_seterror(self->db);
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
cur_value = argv[i];
|
|
switch (sqlite3_value_type(argv[i])) {
|
|
case SQLITE_INTEGER:
|
|
val_int = sqlite3_value_int64(cur_value);
|
|
cur_py_value = PyInt_FromLong((long)val_int);
|
|
break;
|
|
case SQLITE_FLOAT:
|
|
cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));
|
|
break;
|
|
case SQLITE_TEXT:
|
|
val_str = (const char*)sqlite3_value_text(cur_value);
|
|
cur_py_value = PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
|
|
/* TODO: have a way to show errors here */
|
|
if (!cur_py_value) {
|
|
PyErr_Clear();
|
|
Py_INCREF(Py_None);
|
|
cur_py_value = Py_None;
|
|
}
|
|
break;
|
|
case SQLITE_BLOB:
|
|
buflen = sqlite3_value_bytes(cur_value);
|
|
cur_py_value = PyBuffer_New(buflen);
|
|
if (!cur_py_value) {
|
|
break;
|
|
}
|
|
if (PyObject_AsWriteBuffer(cur_py_value, &raw_buffer, &buflen)) {
|
|
Py_DECREF(cur_py_value);
|
|
cur_py_value = NULL;
|
|
break;
|
|
}
|
|
memcpy(raw_buffer, sqlite3_value_blob(cur_value), buflen);
|
|
break;
|
|
case SQLITE_NULL:
|
|
default:
|
|
Py_INCREF(Py_None);
|
|
cur_py_value = Py_None;
|
|
}
|
|
|
|
if (!cur_py_value) {
|
|
Py_DECREF(args);
|
|
return NULL;
|
|
}
|
|
|
|
PyTuple_SetItem(args, i, cur_py_value);
|
|
|
|
}
|
|
|
|
return args;
|
|
}
|
|
|
|
void _pysqlite_func_callback(sqlite3_context* context, int argc, sqlite3_value** argv)
|
|
{
|
|
PyObject* args;
|
|
PyObject* py_func;
|
|
PyObject* py_retval = NULL;
|
|
|
|
PyGILState_STATE threadstate;
|
|
|
|
threadstate = PyGILState_Ensure();
|
|
|
|
py_func = (PyObject*)sqlite3_user_data(context);
|
|
|
|
args = _pysqlite_build_py_params(context, argc, argv);
|
|
if (args) {
|
|
py_retval = PyObject_CallObject(py_func, args);
|
|
Py_DECREF(args);
|
|
}
|
|
|
|
if (py_retval) {
|
|
_pysqlite_set_result(context, py_retval);
|
|
Py_DECREF(py_retval);
|
|
} else {
|
|
if (_enable_callback_tracebacks) {
|
|
PyErr_Print();
|
|
} else {
|
|
PyErr_Clear();
|
|
}
|
|
_sqlite3_result_error(context, "user-defined function raised exception", -1);
|
|
}
|
|
|
|
PyGILState_Release(threadstate);
|
|
}
|
|
|
|
static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params)
|
|
{
|
|
PyObject* args;
|
|
PyObject* function_result = NULL;
|
|
PyObject* aggregate_class;
|
|
PyObject** aggregate_instance;
|
|
PyObject* stepmethod = NULL;
|
|
|
|
PyGILState_STATE threadstate;
|
|
|
|
threadstate = PyGILState_Ensure();
|
|
|
|
aggregate_class = (PyObject*)sqlite3_user_data(context);
|
|
|
|
aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
|
|
|
|
if (*aggregate_instance == 0) {
|
|
*aggregate_instance = PyObject_CallFunction(aggregate_class, "");
|
|
|
|
if (PyErr_Occurred()) {
|
|
*aggregate_instance = 0;
|
|
if (_enable_callback_tracebacks) {
|
|
PyErr_Print();
|
|
} else {
|
|
PyErr_Clear();
|
|
}
|
|
_sqlite3_result_error(context, "user-defined aggregate's '__init__' method raised error", -1);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
stepmethod = PyObject_GetAttrString(*aggregate_instance, "step");
|
|
if (!stepmethod) {
|
|
goto error;
|
|
}
|
|
|
|
args = _pysqlite_build_py_params(context, argc, params);
|
|
if (!args) {
|
|
goto error;
|
|
}
|
|
|
|
function_result = PyObject_CallObject(stepmethod, args);
|
|
Py_DECREF(args);
|
|
|
|
if (!function_result) {
|
|
if (_enable_callback_tracebacks) {
|
|
PyErr_Print();
|
|
} else {
|
|
PyErr_Clear();
|
|
}
|
|
_sqlite3_result_error(context, "user-defined aggregate's 'step' method raised error", -1);
|
|
}
|
|
|
|
error:
|
|
Py_XDECREF(stepmethod);
|
|
Py_XDECREF(function_result);
|
|
|
|
PyGILState_Release(threadstate);
|
|
}
|
|
|
|
void _pysqlite_final_callback(sqlite3_context* context)
|
|
{
|
|
PyObject* function_result = NULL;
|
|
PyObject** aggregate_instance;
|
|
PyObject* aggregate_class;
|
|
|
|
PyGILState_STATE threadstate;
|
|
|
|
threadstate = PyGILState_Ensure();
|
|
|
|
aggregate_class = (PyObject*)sqlite3_user_data(context);
|
|
|
|
aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
|
|
if (!*aggregate_instance) {
|
|
/* this branch is executed if there was an exception in the aggregate's
|
|
* __init__ */
|
|
|
|
goto error;
|
|
}
|
|
|
|
function_result = PyObject_CallMethod(*aggregate_instance, "finalize", "");
|
|
if (!function_result) {
|
|
if (_enable_callback_tracebacks) {
|
|
PyErr_Print();
|
|
} else {
|
|
PyErr_Clear();
|
|
}
|
|
_sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1);
|
|
} else {
|
|
_pysqlite_set_result(context, function_result);
|
|
}
|
|
|
|
error:
|
|
Py_XDECREF(*aggregate_instance);
|
|
Py_XDECREF(function_result);
|
|
|
|
PyGILState_Release(threadstate);
|
|
}
|
|
|
|
void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self)
|
|
{
|
|
PyObject* new_list;
|
|
PyObject* weakref;
|
|
int i;
|
|
|
|
/* we only need to do this once in a while */
|
|
if (self->created_statements++ < 200) {
|
|
return;
|
|
}
|
|
|
|
self->created_statements = 0;
|
|
|
|
new_list = PyList_New(0);
|
|
if (!new_list) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < PyList_Size(self->statements); i++) {
|
|
weakref = PyList_GetItem(self->statements, i);
|
|
if (PyWeakref_GetObject(weakref) != Py_None) {
|
|
if (PyList_Append(new_list, weakref) != 0) {
|
|
Py_DECREF(new_list);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Py_DECREF(self->statements);
|
|
self->statements = new_list;
|
|
}
|
|
|
|
PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
|
|
{
|
|
static char *kwlist[] = {"name", "narg", "func", NULL, NULL};
|
|
|
|
PyObject* func;
|
|
char* name;
|
|
int narg;
|
|
int rc;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO", kwlist,
|
|
&name, &narg, &func))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
rc = sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _pysqlite_func_callback, NULL, NULL);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
/* Workaround for SQLite bug: no error code or string is available here */
|
|
PyErr_SetString(pysqlite_OperationalError, "Error creating function");
|
|
return NULL;
|
|
} else {
|
|
PyDict_SetItem(self->function_pinboard, func, Py_None);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
}
|
|
|
|
PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
|
|
{
|
|
PyObject* aggregate_class;
|
|
|
|
int n_arg;
|
|
char* name;
|
|
static char *kwlist[] = { "name", "n_arg", "aggregate_class", NULL };
|
|
int rc;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO:create_aggregate",
|
|
kwlist, &name, &n_arg, &aggregate_class)) {
|
|
return NULL;
|
|
}
|
|
|
|
rc = sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_pysqlite_step_callback, &_pysqlite_final_callback);
|
|
if (rc != SQLITE_OK) {
|
|
/* Workaround for SQLite bug: no error code or string is available here */
|
|
PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");
|
|
return NULL;
|
|
} else {
|
|
PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
}
|
|
|
|
static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source)
|
|
{
|
|
PyObject *ret;
|
|
int rc;
|
|
PyGILState_STATE gilstate;
|
|
|
|
gilstate = PyGILState_Ensure();
|
|
ret = PyObject_CallFunction((PyObject*)user_arg, "issss", action, arg1, arg2, dbname, access_attempt_source);
|
|
|
|
if (!ret) {
|
|
if (_enable_callback_tracebacks) {
|
|
PyErr_Print();
|
|
} else {
|
|
PyErr_Clear();
|
|
}
|
|
|
|
rc = SQLITE_DENY;
|
|
} else {
|
|
if (PyInt_Check(ret)) {
|
|
rc = (int)PyInt_AsLong(ret);
|
|
} else {
|
|
rc = SQLITE_DENY;
|
|
}
|
|
Py_DECREF(ret);
|
|
}
|
|
|
|
PyGILState_Release(gilstate);
|
|
return rc;
|
|
}
|
|
|
|
PyObject* pysqlite_connection_set_authorizer(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
|
|
{
|
|
PyObject* authorizer_cb;
|
|
|
|
static char *kwlist[] = { "authorizer_callback", NULL };
|
|
int rc;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_authorizer",
|
|
kwlist, &authorizer_cb)) {
|
|
return NULL;
|
|
}
|
|
|
|
rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback");
|
|
return NULL;
|
|
} else {
|
|
PyDict_SetItem(self->function_pinboard, authorizer_cb, Py_None);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
}
|
|
|
|
int pysqlite_check_thread(pysqlite_Connection* self)
|
|
{
|
|
if (self->check_same_thread) {
|
|
if (PyThread_get_thread_ident() != self->thread_ident) {
|
|
PyErr_Format(pysqlite_ProgrammingError,
|
|
"SQLite objects created in a thread can only be used in that same thread."
|
|
"The object was created in thread id %ld and this is thread id %ld",
|
|
self->thread_ident, PyThread_get_thread_ident());
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)
|
|
{
|
|
Py_INCREF(self->isolation_level);
|
|
return self->isolation_level;
|
|
}
|
|
|
|
static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)
|
|
{
|
|
if (!pysqlite_check_connection(self)) {
|
|
return NULL;
|
|
} else {
|
|
return Py_BuildValue("i", sqlite3_total_changes(self->db));
|
|
}
|
|
}
|
|
|
|
static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level)
|
|
{
|
|
PyObject* res;
|
|
PyObject* begin_statement;
|
|
|
|
Py_XDECREF(self->isolation_level);
|
|
|
|
if (self->begin_statement) {
|
|
PyMem_Free(self->begin_statement);
|
|
self->begin_statement = NULL;
|
|
}
|
|
|
|
if (isolation_level == Py_None) {
|
|
Py_INCREF(Py_None);
|
|
self->isolation_level = Py_None;
|
|
|
|
res = pysqlite_connection_commit(self, NULL);
|
|
if (!res) {
|
|
return -1;
|
|
}
|
|
Py_DECREF(res);
|
|
|
|
self->inTransaction = 0;
|
|
} else {
|
|
Py_INCREF(isolation_level);
|
|
self->isolation_level = isolation_level;
|
|
|
|
begin_statement = PyString_FromString("BEGIN ");
|
|
if (!begin_statement) {
|
|
return -1;
|
|
}
|
|
PyString_Concat(&begin_statement, isolation_level);
|
|
if (!begin_statement) {
|
|
return -1;
|
|
}
|
|
|
|
self->begin_statement = PyMem_Malloc(PyString_Size(begin_statement) + 2);
|
|
if (!self->begin_statement) {
|
|
return -1;
|
|
}
|
|
|
|
strcpy(self->begin_statement, PyString_AsString(begin_statement));
|
|
Py_DECREF(begin_statement);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
PyObject* pysqlite_connection_call(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
|
|
{
|
|
PyObject* sql;
|
|
pysqlite_Statement* statement;
|
|
PyObject* weakref;
|
|
int rc;
|
|
|
|
if (!PyArg_ParseTuple(args, "O", &sql)) {
|
|
return NULL;
|
|
}
|
|
|
|
_pysqlite_drop_unused_statement_references(self);
|
|
|
|
statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType);
|
|
if (!statement) {
|
|
return NULL;
|
|
}
|
|
|
|
rc = pysqlite_statement_create(statement, self, sql);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
if (rc == PYSQLITE_TOO_MUCH_SQL) {
|
|
PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time.");
|
|
} else if (rc == PYSQLITE_SQL_WRONG_TYPE) {
|
|
PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string or unicode.");
|
|
} else {
|
|
_pysqlite_seterror(self->db);
|
|
}
|
|
|
|
Py_DECREF(statement);
|
|
statement = 0;
|
|
} else {
|
|
weakref = PyWeakref_NewRef((PyObject*)statement, NULL);
|
|
if (!weakref) {
|
|
Py_DECREF(statement);
|
|
statement = 0;
|
|
goto error;
|
|
}
|
|
|
|
if (PyList_Append(self->statements, weakref) != 0) {
|
|
Py_DECREF(weakref);
|
|
statement = 0;
|
|
goto error;
|
|
}
|
|
|
|
Py_DECREF(weakref);
|
|
}
|
|
|
|
error:
|
|
return (PyObject*)statement;
|
|
}
|
|
|
|
PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
|
|
{
|
|
PyObject* cursor = 0;
|
|
PyObject* result = 0;
|
|
PyObject* method = 0;
|
|
|
|
cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
|
|
if (!cursor) {
|
|
goto error;
|
|
}
|
|
|
|
method = PyObject_GetAttrString(cursor, "execute");
|
|
if (!method) {
|
|
Py_DECREF(cursor);
|
|
cursor = 0;
|
|
goto error;
|
|
}
|
|
|
|
result = PyObject_CallObject(method, args);
|
|
if (!result) {
|
|
Py_DECREF(cursor);
|
|
cursor = 0;
|
|
}
|
|
|
|
error:
|
|
Py_XDECREF(result);
|
|
Py_XDECREF(method);
|
|
|
|
return cursor;
|
|
}
|
|
|
|
PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
|
|
{
|
|
PyObject* cursor = 0;
|
|
PyObject* result = 0;
|
|
PyObject* method = 0;
|
|
|
|
cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
|
|
if (!cursor) {
|
|
goto error;
|
|
}
|
|
|
|
method = PyObject_GetAttrString(cursor, "executemany");
|
|
if (!method) {
|
|
Py_DECREF(cursor);
|
|
cursor = 0;
|
|
goto error;
|
|
}
|
|
|
|
result = PyObject_CallObject(method, args);
|
|
if (!result) {
|
|
Py_DECREF(cursor);
|
|
cursor = 0;
|
|
}
|
|
|
|
error:
|
|
Py_XDECREF(result);
|
|
Py_XDECREF(method);
|
|
|
|
return cursor;
|
|
}
|
|
|
|
PyObject* pysqlite_connection_executescript(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
|
|
{
|
|
PyObject* cursor = 0;
|
|
PyObject* result = 0;
|
|
PyObject* method = 0;
|
|
|
|
cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
|
|
if (!cursor) {
|
|
goto error;
|
|
}
|
|
|
|
method = PyObject_GetAttrString(cursor, "executescript");
|
|
if (!method) {
|
|
Py_DECREF(cursor);
|
|
cursor = 0;
|
|
goto error;
|
|
}
|
|
|
|
result = PyObject_CallObject(method, args);
|
|
if (!result) {
|
|
Py_DECREF(cursor);
|
|
cursor = 0;
|
|
}
|
|
|
|
error:
|
|
Py_XDECREF(result);
|
|
Py_XDECREF(method);
|
|
|
|
return cursor;
|
|
}
|
|
|
|
/* ------------------------- COLLATION CODE ------------------------ */
|
|
|
|
static int
|
|
pysqlite_collation_callback(
|
|
void* context,
|
|
int text1_length, const void* text1_data,
|
|
int text2_length, const void* text2_data)
|
|
{
|
|
PyObject* callback = (PyObject*)context;
|
|
PyObject* string1 = 0;
|
|
PyObject* string2 = 0;
|
|
PyGILState_STATE gilstate;
|
|
|
|
PyObject* retval = NULL;
|
|
int result = 0;
|
|
|
|
gilstate = PyGILState_Ensure();
|
|
|
|
if (PyErr_Occurred()) {
|
|
goto finally;
|
|
}
|
|
|
|
string1 = PyString_FromStringAndSize((const char*)text1_data, text1_length);
|
|
string2 = PyString_FromStringAndSize((const char*)text2_data, text2_length);
|
|
|
|
if (!string1 || !string2) {
|
|
goto finally; /* failed to allocate strings */
|
|
}
|
|
|
|
retval = PyObject_CallFunctionObjArgs(callback, string1, string2, NULL);
|
|
|
|
if (!retval) {
|
|
/* execution failed */
|
|
goto finally;
|
|
}
|
|
|
|
result = PyInt_AsLong(retval);
|
|
if (PyErr_Occurred()) {
|
|
result = 0;
|
|
}
|
|
|
|
finally:
|
|
Py_XDECREF(string1);
|
|
Py_XDECREF(string2);
|
|
Py_XDECREF(retval);
|
|
|
|
PyGILState_Release(gilstate);
|
|
|
|
return result;
|
|
}
|
|
|
|
static PyObject *
|
|
pysqlite_connection_interrupt(pysqlite_Connection* self, PyObject* args)
|
|
{
|
|
PyObject* retval = NULL;
|
|
|
|
if (!pysqlite_check_connection(self)) {
|
|
goto finally;
|
|
}
|
|
|
|
sqlite3_interrupt(self->db);
|
|
|
|
Py_INCREF(Py_None);
|
|
retval = Py_None;
|
|
|
|
finally:
|
|
return retval;
|
|
}
|
|
|
|
static PyObject *
|
|
pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args)
|
|
{
|
|
PyObject* callable;
|
|
PyObject* uppercase_name = 0;
|
|
PyObject* name;
|
|
PyObject* retval;
|
|
char* chk;
|
|
int rc;
|
|
|
|
if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
|
|
goto finally;
|
|
}
|
|
|
|
if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyString_Type, &name, &callable)) {
|
|
goto finally;
|
|
}
|
|
|
|
uppercase_name = PyObject_CallMethod(name, "upper", "");
|
|
if (!uppercase_name) {
|
|
goto finally;
|
|
}
|
|
|
|
chk = PyString_AsString(uppercase_name);
|
|
while (*chk) {
|
|
if ((*chk >= '0' && *chk <= '9')
|
|
|| (*chk >= 'A' && *chk <= 'Z')
|
|
|| (*chk == '_'))
|
|
{
|
|
chk++;
|
|
} else {
|
|
PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name");
|
|
goto finally;
|
|
}
|
|
}
|
|
|
|
if (callable != Py_None && !PyCallable_Check(callable)) {
|
|
PyErr_SetString(PyExc_TypeError, "parameter must be callable");
|
|
goto finally;
|
|
}
|
|
|
|
if (callable != Py_None) {
|
|
PyDict_SetItem(self->collations, uppercase_name, callable);
|
|
} else {
|
|
PyDict_DelItem(self->collations, uppercase_name);
|
|
}
|
|
|
|
rc = sqlite3_create_collation(self->db,
|
|
PyString_AsString(uppercase_name),
|
|
SQLITE_UTF8,
|
|
(callable != Py_None) ? callable : NULL,
|
|
(callable != Py_None) ? pysqlite_collation_callback : NULL);
|
|
if (rc != SQLITE_OK) {
|
|
PyDict_DelItem(self->collations, uppercase_name);
|
|
_pysqlite_seterror(self->db);
|
|
goto finally;
|
|
}
|
|
|
|
finally:
|
|
Py_XDECREF(uppercase_name);
|
|
|
|
if (PyErr_Occurred()) {
|
|
retval = NULL;
|
|
} else {
|
|
Py_INCREF(Py_None);
|
|
retval = Py_None;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
static char connection_doc[] =
|
|
PyDoc_STR("SQLite database connection object.");
|
|
|
|
static PyGetSetDef connection_getset[] = {
|
|
{"isolation_level", (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
|
|
{"total_changes", (getter)pysqlite_connection_get_total_changes, (setter)0},
|
|
{NULL}
|
|
};
|
|
|
|
static PyMethodDef connection_methods[] = {
|
|
{"cursor", (PyCFunction)pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS,
|
|
PyDoc_STR("Return a cursor for the connection.")},
|
|
{"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS,
|
|
PyDoc_STR("Closes the connection.")},
|
|
{"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS,
|
|
PyDoc_STR("Commit the current transaction.")},
|
|
{"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS,
|
|
PyDoc_STR("Roll back the current transaction.")},
|
|
{"create_function", (PyCFunction)pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS,
|
|
PyDoc_STR("Creates a new function. Non-standard.")},
|
|
{"create_aggregate", (PyCFunction)pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS,
|
|
PyDoc_STR("Creates a new aggregate. Non-standard.")},
|
|
{"set_authorizer", (PyCFunction)pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS,
|
|
PyDoc_STR("Sets authorizer callback. Non-standard.")},
|
|
{"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS,
|
|
PyDoc_STR("Executes a SQL statement. Non-standard.")},
|
|
{"executemany", (PyCFunction)pysqlite_connection_executemany, METH_VARARGS,
|
|
PyDoc_STR("Repeatedly executes a SQL statement. Non-standard.")},
|
|
{"executescript", (PyCFunction)pysqlite_connection_executescript, METH_VARARGS,
|
|
PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
|
|
{"create_collation", (PyCFunction)pysqlite_connection_create_collation, METH_VARARGS,
|
|
PyDoc_STR("Creates a collation function. Non-standard.")},
|
|
{"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS,
|
|
PyDoc_STR("Abort any pending database operation. Non-standard.")},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static struct PyMemberDef connection_members[] =
|
|
{
|
|
{"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), RO},
|
|
{"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), RO},
|
|
{"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), RO},
|
|
{"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), RO},
|
|
{"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), RO},
|
|
{"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), RO},
|
|
{"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), RO},
|
|
{"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), RO},
|
|
{"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), RO},
|
|
{"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), RO},
|
|
{"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)},
|
|
{"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)},
|
|
{NULL}
|
|
};
|
|
|
|
PyTypeObject pysqlite_ConnectionType = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0, /* ob_size */
|
|
MODULE_NAME ".Connection", /* tp_name */
|
|
sizeof(pysqlite_Connection), /* tp_basicsize */
|
|
0, /* tp_itemsize */
|
|
(destructor)pysqlite_connection_dealloc, /* tp_dealloc */
|
|
0, /* tp_print */
|
|
0, /* tp_getattr */
|
|
0, /* tp_setattr */
|
|
0, /* tp_compare */
|
|
0, /* tp_repr */
|
|
0, /* tp_as_number */
|
|
0, /* tp_as_sequence */
|
|
0, /* tp_as_mapping */
|
|
0, /* tp_hash */
|
|
(ternaryfunc)pysqlite_connection_call, /* tp_call */
|
|
0, /* tp_str */
|
|
0, /* tp_getattro */
|
|
0, /* tp_setattro */
|
|
0, /* tp_as_buffer */
|
|
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
connection_doc, /* tp_doc */
|
|
0, /* tp_traverse */
|
|
0, /* tp_clear */
|
|
0, /* tp_richcompare */
|
|
0, /* tp_weaklistoffset */
|
|
0, /* tp_iter */
|
|
0, /* tp_iternext */
|
|
connection_methods, /* tp_methods */
|
|
connection_members, /* tp_members */
|
|
connection_getset, /* tp_getset */
|
|
0, /* tp_base */
|
|
0, /* tp_dict */
|
|
0, /* tp_descr_get */
|
|
0, /* tp_descr_set */
|
|
0, /* tp_dictoffset */
|
|
(initproc)pysqlite_connection_init, /* tp_init */
|
|
0, /* tp_alloc */
|
|
0, /* tp_new */
|
|
0 /* tp_free */
|
|
};
|
|
|
|
extern int pysqlite_connection_setup_types(void)
|
|
{
|
|
pysqlite_ConnectionType.tp_new = PyType_GenericNew;
|
|
return PyType_Ready(&pysqlite_ConnectionType);
|
|
}
|