self->Error = state->Error;
self->InterfaceError = state->InterfaceError;
self->DatabaseError = state->DatabaseError;
- self->DataError = pysqlite_DataError;
- self->OperationalError = pysqlite_OperationalError;
- self->IntegrityError = pysqlite_IntegrityError;
+ self->DataError = state->DataError;
+ self->OperationalError = state->OperationalError;
+ self->IntegrityError = state->IntegrityError;
self->InternalError = state->InternalError;
- self->ProgrammingError = pysqlite_ProgrammingError;
- self->NotSupportedError = pysqlite_NotSupportedError;
+ self->ProgrammingError = state->ProgrammingError;
+ self->NotSupportedError = state->NotSupportedError;
if (PySys_Audit("sqlite3.connect/handle", "O", self) < 0) {
return -1;
*/
int pysqlite_check_connection(pysqlite_Connection* con)
{
+ pysqlite_state *state = pysqlite_get_state(NULL);
if (!con->initialized) {
- PyErr_SetString(pysqlite_ProgrammingError, "Base Connection.__init__ not called.");
+ PyErr_SetString(state->ProgrammingError,
+ "Base Connection.__init__ not called.");
return 0;
}
if (!con->db) {
- PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database.");
+ PyErr_SetString(state->ProgrammingError,
+ "Cannot operate on a closed database.");
return 0;
} else {
return 1;
if (deterministic) {
#if SQLITE_VERSION_NUMBER < 3008003
- PyErr_SetString(pysqlite_NotSupportedError,
+ PyErr_SetString(self->NotSupportedError,
"deterministic=True requires SQLite 3.8.3 or higher");
return NULL;
#else
if (sqlite3_libversion_number() < 3008003) {
- PyErr_SetString(pysqlite_NotSupportedError,
+ PyErr_SetString(self->NotSupportedError,
"deterministic=True requires SQLite 3.8.3 or higher");
return NULL;
}
if (rc != SQLITE_OK) {
/* Workaround for SQLite bug: no error code or string is available here */
- PyErr_SetString(pysqlite_OperationalError, "Error creating function");
+ PyErr_SetString(self->OperationalError, "Error creating function");
return NULL;
}
Py_RETURN_NONE;
&_destructor); // will decref func
if (rc != SQLITE_OK) {
/* Workaround for SQLite bug: no error code or string is available here */
- PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");
+ PyErr_SetString(self->OperationalError, "Error creating aggregate");
return NULL;
}
Py_RETURN_NONE;
rc = sqlite3_set_authorizer(self->db, _authorizer_callback, authorizer_cb);
}
if (rc != SQLITE_OK) {
- PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback");
+ PyErr_SetString(self->OperationalError,
+ "Error setting authorizer callback");
Py_XSETREF(self->function_pinboard_authorizer_cb, NULL);
return NULL;
}
rc = sqlite3_enable_load_extension(self->db, onoff);
if (rc != SQLITE_OK) {
- PyErr_SetString(pysqlite_OperationalError, "Error enabling load extension");
+ PyErr_SetString(self->OperationalError,
+ "Error enabling load extension");
return NULL;
} else {
Py_RETURN_NONE;
rc = sqlite3_load_extension(self->db, extension_name, 0, &errmsg);
if (rc != 0) {
- PyErr_SetString(pysqlite_OperationalError, errmsg);
+ PyErr_SetString(self->OperationalError, errmsg);
return NULL;
} else {
Py_RETURN_NONE;
{
if (self->check_same_thread) {
if (PyThread_get_thread_ident() != self->thread_ident) {
- PyErr_Format(pysqlite_ProgrammingError,
+ PyErr_Format(self->ProgrammingError,
"SQLite objects created in a thread can only be used in that same thread. "
"The object was created in thread id %lu and this is thread id %lu.",
self->thread_ident, PyThread_get_thread_ident());
pyfn_iterdump = _PyDict_GetItemIdWithError(module_dict, &PyId__iterdump);
if (!pyfn_iterdump) {
if (!PyErr_Occurred()) {
- PyErr_SetString(pysqlite_OperationalError,
+ PyErr_SetString(self->OperationalError,
"Failed to obtain _iterdump() reference");
}
goto finally;
/* Since 3.8.8 this is already done, per commit
https://www.sqlite.org/src/info/169b5505498c0a7e */
if (!sqlite3_get_autocommit(target->db)) {
- PyErr_SetString(pysqlite_OperationalError, "target is in transaction");
+ PyErr_SetString(self->OperationalError, "target is in transaction");
return NULL;
}
#endif
{
continue;
} else {
- PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name");
+ PyErr_SetString(self->ProgrammingError,
+ "invalid character in collation name");
goto finally;
}
}
PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'",
colname , text);
error_msg = PyUnicode_Decode(buf, strlen(buf), "ascii", "replace");
+
+ PyObject *exc = self->connection->OperationalError;
if (!error_msg) {
- PyErr_SetString(pysqlite_OperationalError, "Could not decode to UTF-8");
+ PyErr_SetString(exc, "Could not decode to UTF-8");
} else {
- PyErr_SetObject(pysqlite_OperationalError, error_msg);
+ PyErr_SetObject(exc, error_msg);
Py_DECREF(error_msg);
}
}
*/
static int check_cursor(pysqlite_Cursor* cur)
{
+ pysqlite_state *state = pysqlite_get_state(NULL);
+
if (!cur->initialized) {
- PyErr_SetString(pysqlite_ProgrammingError, "Base Cursor.__init__ not called.");
+ PyErr_SetString(state->ProgrammingError,
+ "Base Cursor.__init__ not called.");
return 0;
}
if (cur->closed) {
- PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed cursor.");
+ PyErr_SetString(state->ProgrammingError,
+ "Cannot operate on a closed cursor.");
return 0;
}
if (cur->locked) {
- PyErr_SetString(pysqlite_ProgrammingError, "Recursive use of cursors not allowed.");
+ PyErr_SetString(state->ProgrammingError,
+ "Recursive use of cursors not allowed.");
return 0;
}
}
if (pysqlite_build_row_cast_map(self) != 0) {
- _PyErr_FormatFromCause(pysqlite_OperationalError, "Error while building row_cast_map");
+ _PyErr_FormatFromCause(self->connection->OperationalError,
+ "Error while building row_cast_map");
goto error;
}
if (rc == SQLITE_ROW) {
if (multiple) {
- PyErr_SetString(pysqlite_ProgrammingError, "executemany() can only execute DML statements.");
+ PyErr_SetString(self->connection->ProgrammingError,
+ "executemany() can only execute DML "
+ "statements.");
goto error;
}
int max_length = sqlite3_limit(self->connection->db,
SQLITE_LIMIT_LENGTH, -1);
if (sql_len >= max_length) {
- PyErr_SetString(pysqlite_DataError, "query string is too large");
+ PyErr_SetString(self->connection->DataError,
+ "query string is too large");
return NULL;
}
} else {
/*[clinic end generated code: output=b6055e4ec6fe63b6 input=08b36552dbb9a986]*/
{
if (!self->connection) {
- PyErr_SetString(pysqlite_ProgrammingError,
+ pysqlite_state *state = pysqlite_get_state(NULL);
+ PyErr_SetString(state->ProgrammingError,
"Base Cursor.__init__ not called.");
return NULL;
}
return Py_NewRef(alt);
}
/* else set the right exception and return NULL */
- PyErr_SetString(pysqlite_ProgrammingError, "can't adapt");
+ pysqlite_state *state = pysqlite_get_state(NULL);
+ PyErr_SetString(state->ProgrammingError, "can't adapt");
return NULL;
}
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=81e330492d57488e]*/
/* static objects at module-level */
-
-PyObject *pysqlite_OperationalError = NULL;
-PyObject *pysqlite_ProgrammingError = NULL;
-PyObject *pysqlite_IntegrityError = NULL;
-PyObject *pysqlite_DataError = NULL;
-PyObject *pysqlite_NotSupportedError = NULL;
-
PyObject* _pysqlite_converters = NULL;
int _pysqlite_enable_callback_tracebacks = 0;
int pysqlite_BaseTypeAdapted = 0;
rc = sqlite3_enable_shared_cache(do_enable);
if (rc != SQLITE_OK) {
- PyErr_SetString(pysqlite_OperationalError, "Changing the shared_cache flag failed");
+ pysqlite_state *state = pysqlite_get_state(module);
+ PyErr_SetString(state->OperationalError, "Changing the shared_cache flag failed");
return NULL;
} else {
Py_RETURN_NONE;
} \
} while (0)
-#define ADD_EXCEPTION(module, name, exc, base) \
-do { \
- exc = PyErr_NewException(MODULE_NAME "." name, base, NULL); \
- if (!exc) { \
- goto error; \
- } \
- int res = PyModule_AddObjectRef(module, name, exc); \
- Py_DECREF(exc); \
- if (res < 0) { \
- goto error; \
- } \
+#define ADD_EXCEPTION(module, state, exc, base) \
+do { \
+ state->exc = PyErr_NewException(MODULE_NAME "." #exc, base, NULL); \
+ if (state->exc == NULL) { \
+ goto error; \
+ } \
+ ADD_TYPE(module, (PyTypeObject *)state->exc); \
} while (0)
PyMODINIT_FUNC PyInit__sqlite3(void)
ADD_TYPE(module, state->RowType);
/*** Create DB-API Exception hierarchy */
- ADD_EXCEPTION(module, "Error", state->Error, PyExc_Exception);
- ADD_EXCEPTION(module, "Warning", state->Warning, PyExc_Exception);
+ ADD_EXCEPTION(module, state, Error, PyExc_Exception);
+ ADD_EXCEPTION(module, state, Warning, PyExc_Exception);
/* Error subclasses */
- ADD_EXCEPTION(module, "InterfaceError", state->InterfaceError,
- state->Error);
- ADD_EXCEPTION(module, "DatabaseError", state->DatabaseError, state->Error);
+ ADD_EXCEPTION(module, state, InterfaceError, state->Error);
+ ADD_EXCEPTION(module, state, DatabaseError, state->Error);
/* DatabaseError subclasses */
- ADD_EXCEPTION(module, "InternalError", state->InternalError,
- state->DatabaseError);
- ADD_EXCEPTION(module, "OperationalError", pysqlite_OperationalError,
- state->DatabaseError);
- ADD_EXCEPTION(module, "ProgrammingError", pysqlite_ProgrammingError,
- state->DatabaseError);
- ADD_EXCEPTION(module, "IntegrityError", pysqlite_IntegrityError,
- state->DatabaseError);
- ADD_EXCEPTION(module, "DataError", pysqlite_DataError,
- state->DatabaseError);
- ADD_EXCEPTION(module, "NotSupportedError", pysqlite_NotSupportedError,
- state->DatabaseError);
+ ADD_EXCEPTION(module, state, InternalError, state->DatabaseError);
+ ADD_EXCEPTION(module, state, OperationalError, state->DatabaseError);
+ ADD_EXCEPTION(module, state, ProgrammingError, state->DatabaseError);
+ ADD_EXCEPTION(module, state, IntegrityError, state->DatabaseError);
+ ADD_EXCEPTION(module, state, DataError, state->DatabaseError);
+ ADD_EXCEPTION(module, state, NotSupportedError, state->DatabaseError);
/* Set integer constants */
if (add_integer_constants(module) < 0) {
#define MODULE_NAME "sqlite3"
typedef struct {
+ PyObject *DataError;
PyObject *DatabaseError;
PyObject *Error;
+ PyObject *IntegrityError;
PyObject *InterfaceError;
PyObject *InternalError;
+ PyObject *NotSupportedError;
+ PyObject *OperationalError;
+ PyObject *ProgrammingError;
PyObject *Warning;
+
PyObject *lru_cache;
+
PyTypeObject *ConnectionType;
PyTypeObject *CursorType;
PyTypeObject *PrepareProtocolType;
return &pysqlite_global_state;
}
-extern PyObject* pysqlite_OperationalError;
-extern PyObject* pysqlite_ProgrammingError;
-extern PyObject* pysqlite_IntegrityError;
-extern PyObject* pysqlite_DataError;
-extern PyObject* pysqlite_NotSupportedError;
-
/* A dictionary, mapping column types (INTEGER, VARCHAR, etc.) to converter
* functions, that convert the SQL value to the appropriate Python value.
* The key is uppercase.
Py_ssize_t size;
const char *sql_cstr = PyUnicode_AsUTF8AndSize(sql, &size);
if (sql_cstr == NULL) {
- PyObject *exc = connection->Warning;
- PyErr_Format(exc, "SQL is of wrong type ('%s'). Must be string.",
+ PyErr_Format(connection->Warning,
+ "SQL is of wrong type ('%s'). Must be string.",
Py_TYPE(sql)->tp_name);
return NULL;
}
sqlite3 *db = connection->db;
int max_length = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1);
if (size >= max_length) {
- PyErr_SetString(pysqlite_DataError, "query string is too large");
+ PyErr_SetString(connection->DataError,
+ "query string is too large");
return NULL;
}
if (strlen(sql_cstr) != (size_t)size) {
}
if (pysqlite_check_remaining_sql(tail)) {
- PyObject *exc = connection->Warning;
- PyErr_SetString(exc, "You can only execute one statement at a time.");
+ PyErr_SetString(connection->Warning,
+ "You can only execute one statement at a time.");
goto error;
}
}
}
if (num_params != num_params_needed) {
- PyErr_Format(pysqlite_ProgrammingError,
+ PyErr_Format(state->ProgrammingError,
"Incorrect number of bindings supplied. The current "
"statement uses %d, and there are %zd supplied.",
num_params_needed, num_params);
binding_name = sqlite3_bind_parameter_name(self->st, i);
Py_END_ALLOW_THREADS
if (!binding_name) {
- PyErr_Format(pysqlite_ProgrammingError, "Binding %d has no name, but you supplied a dictionary (which has only names).", i);
+ PyErr_Format(state->ProgrammingError,
+ "Binding %d has no name, but you supplied a "
+ "dictionary (which has only names).", i);
return;
}
Py_DECREF(binding_name_obj);
if (!current_param) {
if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_LookupError)) {
- PyErr_Format(pysqlite_ProgrammingError, "You did not supply a value for binding parameter :%s.", binding_name);
+ PyErr_Format(state->ProgrammingError,
+ "You did not supply a value for binding "
+ "parameter :%s.", binding_name);
}
return;
}
case SQLITE_PROTOCOL:
case SQLITE_EMPTY:
case SQLITE_SCHEMA:
- PyErr_SetString(pysqlite_OperationalError, sqlite3_errmsg(db));
+ PyErr_SetString(state->OperationalError, sqlite3_errmsg(db));
break;
case SQLITE_CORRUPT:
PyErr_SetString(state->DatabaseError, sqlite3_errmsg(db));
break;
case SQLITE_TOOBIG:
- PyErr_SetString(pysqlite_DataError, sqlite3_errmsg(db));
+ PyErr_SetString(state->DataError, sqlite3_errmsg(db));
break;
case SQLITE_CONSTRAINT:
case SQLITE_MISMATCH:
- PyErr_SetString(pysqlite_IntegrityError, sqlite3_errmsg(db));
+ PyErr_SetString(state->IntegrityError, sqlite3_errmsg(db));
break;
case SQLITE_MISUSE:
- PyErr_SetString(pysqlite_ProgrammingError, sqlite3_errmsg(db));
+ PyErr_SetString(state->ProgrammingError, sqlite3_errmsg(db));
break;
default:
PyErr_SetString(state->DatabaseError, sqlite3_errmsg(db));
Modules/_io/_iomodule.h - _PyIO_empty_str -
Modules/_io/_iomodule.h - _PyIO_empty_bytes -
Modules/_multiprocessing/multiprocessing.h - _PyMp_SemLockType -
-Modules/_sqlite/module.c - pysqlite_OperationalError -
-Modules/_sqlite/module.c - pysqlite_ProgrammingError -
-Modules/_sqlite/module.c - pysqlite_IntegrityError -
-Modules/_sqlite/module.c - pysqlite_DataError -
-Modules/_sqlite/module.c - pysqlite_NotSupportedError -
Modules/_sqlite/module.c - _pysqlite_converters -
Modules/_sqlite/module.c - _pysqlite_enable_callback_tracebacks -
Modules/_sqlite/module.c - pysqlite_BaseTypeAdapted -
Modules/_cursesmodule.c - PyCursesError -
Modules/_decimal/_decimal.c - DecimalException -
Modules/_queuemodule.c - EmptyError -
-Modules/_sqlite/module.h - pysqlite_OperationalError -
-Modules/_sqlite/module.h - pysqlite_ProgrammingError -
-Modules/_sqlite/module.h - pysqlite_IntegrityError -
-Modules/_sqlite/module.h - pysqlite_DataError -
-Modules/_sqlite/module.h - pysqlite_NotSupportedError -
Modules/_ssl.c - PySSLErrorObject -
Modules/_ssl.c - PySSLCertVerificationErrorObject -
Modules/_ssl.c - PySSLZeroReturnErrorObject -
projects / thirdparty / Python / cpython.git / commitdiff
