#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "module.h"

#include "connection.h"

#include "statement.h"

#include "cursor.h"

#include "blob.h"

#include "prepare_protocol.h"

#include "util.h"

#include "pycore_modsupport.h" // _PyArg_NoKeywords()

#include "pycore_pyerrors.h" // _PyErr_ChainExceptions1()

#include "pycore_pylifecycle.h" // _Py_IsInterpreterFinalizing()

#include "pycore_weakref.h"

#include <stdbool.h>

#if SQLITE_VERSION_NUMBER >= 3025000

#define HAVE_WINDOW_FUNCTIONS

static const char *

get_isolation_level(const char *level)

{

assert(level != NULL);

static const char *const allowed_levels[] = {

"",

"DEFERRED",

"IMMEDIATE",

"EXCLUSIVE",

NULL

};

for (int i = 0; allowed_levels[i] != NULL; i++) {

const char *candidate = allowed_levels[i];

if (sqlite3_stricmp(level, candidate) == 0) {

return candidate;

}

}

PyErr_SetString(PyExc_ValueError,

"isolation_level string must be '', 'DEFERRED', "

"'IMMEDIATE', or 'EXCLUSIVE'");

return NULL;

}

static int

isolation_level_converter(PyObject *str_or_none, const char **result)

{

if (Py_IsNone(str_or_none)) {

*result = NULL;

}

else if (PyUnicode_Check(str_or_none)) {

const char *str = _PyUnicode_AsUTF8NoNUL(str_or_none);

if (str == NULL) {

return 0;

}

const char *level = get_isolation_level(str);

if (level == NULL) {

return 0;

}

*result = level;

}

else {

PyErr_SetString(PyExc_TypeError,

"isolation_level must be str or None");

return 0;

}

return 1;

}

static int

autocommit_converter(PyObject *val, enum autocommit_mode *result)

{

if (Py_IsTrue(val)) {

*result = AUTOCOMMIT_ENABLED;

return 1;

}

if (Py_IsFalse(val)) {

*result = AUTOCOMMIT_DISABLED;

return 1;

}

if (PyLong_Check(val) &&

PyLong_AsLong(val) == LEGACY_TRANSACTION_CONTROL)

{

*result = AUTOCOMMIT_LEGACY;

return 1;

}

PyErr_SetString(PyExc_ValueError,

"autocommit must be True, False, or "

"sqlite3.LEGACY_TRANSACTION_CONTROL");

return 0;

}

static int

sqlite3_int64_converter(PyObject *obj, sqlite3_int64 *result)

{

if (!PyLong_Check(obj)) {

PyErr_SetString(PyExc_TypeError, "expected 'int'");

return 0;

}

*result = _pysqlite_long_as_int64(obj);

if (PyErr_Occurred()) {

return 0;

}

return 1;

}

#define clinic_state() (pysqlite_get_state_by_type(Py_TYPE(self)))

#include "clinic/connection.c.h"

#undef clinic_state

#define _pysqlite_Connection_CAST(op) ((pysqlite_Connection *)(op))

static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self);

static void free_callback_context(callback_context *ctx);

static void set_callback_context(callback_context **ctx_pp,

callback_context *ctx);

static int connection_close(pysqlite_Connection *self);

PyObject *_pysqlite_query_execute(pysqlite_Cursor *, int, PyObject *, PyObject *);

static PyObject *

new_statement_cache(pysqlite_Connection *self, pysqlite_state *state,

int maxsize)

{

PyObject *args[] = { NULL, PyLong_FromLong(maxsize), };

if (args[1] == NULL) {

return NULL;

}

PyObject *lru_cache = state->lru_cache;

size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;

PyObject *inner = PyObject_Vectorcall(lru_cache, args + 1, nargsf, NULL);

Py_DECREF(args[1]);

if (inner == NULL) {

return NULL;

}

args[1] = (PyObject *)self; // Borrowed ref.

nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;

PyObject *res = PyObject_Vectorcall(inner, args + 1, nargsf, NULL);

Py_DECREF(inner);

return res;

}

static inline int

connection_exec_stmt(pysqlite_Connection *self, const char *sql)

{

int rc;

Py_BEGIN_ALLOW_THREADS

int len = (int)strlen(sql) + 1;

sqlite3_stmt *stmt;

rc = sqlite3_prepare_v2(self->db, sql, len, &stmt, NULL);

if (rc == SQLITE_OK) {

(void)sqlite3_step(stmt);

rc = sqlite3_finalize(stmt);

}

Py_END_ALLOW_THREADS

if (rc != SQLITE_OK) {

set_error_from_db(self->state, self->db);

return -1;

}

return 0;

}

static int

pysqlite_connection_init_impl(pysqlite_Connection *self, PyObject *database,

enum autocommit_mode autocommit)

{

if (PySys_Audit("sqlite3.connect", "O", database) < 0) {

return -1;

}

PyObject *bytes;

if (!PyUnicode_FSConverter(database, &bytes)) {

return -1;

}

if (self->initialized) {

self->initialized = 0;

PyTypeObject *tp = Py_TYPE(self);

tp->tp_clear((PyObject *)self);

if (connection_close(self) < 0) {

return -1;

}

}

// Create and configure SQLite database object.

sqlite3 *db;

int rc;

Py_BEGIN_ALLOW_THREADS

rc = sqlite3_open_v2(PyBytes_AS_STRING(bytes), &db,

SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |

(uri ? SQLITE_OPEN_URI : 0), NULL);

if (rc == SQLITE_OK) {

(void)sqlite3_busy_timeout(db, (int)(timeout*1000));

}

Py_END_ALLOW_THREADS

Py_DECREF(bytes);

if (db == NULL && rc == SQLITE_NOMEM) {

PyErr_NoMemory();

return -1;

}

pysqlite_state *state = pysqlite_get_state_by_type(Py_TYPE(self));

if (rc != SQLITE_OK) {

set_error_from_db(state, db);

goto error;

}

// Create LRU statement cache; returns a new reference.

PyObject *statement_cache = new_statement_cache(self, state, cache_size);

if (statement_cache == NULL) {

goto error;

}

/* Create lists of weak references to cursors and blobs */

PyObject *cursors = PyList_New(0);

if (cursors == NULL) {

Py_DECREF(statement_cache);

goto error;

}

PyObject *blobs = PyList_New(0);

if (blobs == NULL) {

Py_DECREF(statement_cache);

Py_DECREF(cursors);

goto error;

}

// Init connection state members.

self->db = db;

self->state = state;

self->detect_types = detect_types;

self->isolation_level = isolation_level;

self->autocommit = autocommit;

self->check_same_thread = check_same_thread;

self->thread_ident = PyThread_get_thread_ident();

self->statement_cache = statement_cache;

self->cursors = cursors;

self->blobs = blobs;

self->created_cursors = 0;

self->row_factory = Py_NewRef(Py_None);

self->text_factory = Py_NewRef(&PyUnicode_Type);

self->trace_ctx = NULL;

self->progress_ctx = NULL;

self->authorizer_ctx = NULL;

// Borrowed refs

self->Warning = state->Warning;

self->Error = state->Error;

self->InterfaceError = state->InterfaceError;

self->DatabaseError = state->DatabaseError;

self->DataError = state->DataError;

self->OperationalError = state->OperationalError;

self->IntegrityError = state->IntegrityError;

self->InternalError = state->InternalError;

self->ProgrammingError = state->ProgrammingError;

self->NotSupportedError = state->NotSupportedError;

if (PySys_Audit("sqlite3.connect/handle", "O", self) < 0) {

return -1; // Don't goto error; at this point, dealloc will clean up.

}

self->initialized = 1;

if (autocommit == AUTOCOMMIT_DISABLED) {

if (connection_exec_stmt(self, "BEGIN") < 0) {

return -1;

}

}

return 0;

error:

// There are no statements or other SQLite objects attached to the

// database, so sqlite3_close() should always return SQLITE_OK.

rc = sqlite3_close(db);

assert(rc == SQLITE_OK);

return -1;

}

#define VISIT_CALLBACK_CONTEXT(ctx) \

do { \

if (ctx) { \

Py_VISIT(ctx->callable); \

Py_VISIT(ctx->module); \

} \

} while (0)

static int

connection_traverse(PyObject *op, visitproc visit, void *arg)

{

pysqlite_Connection *self = _pysqlite_Connection_CAST(op);

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->statement_cache);

Py_VISIT(self->cursors);

Py_VISIT(self->blobs);

Py_VISIT(self->row_factory);

Py_VISIT(self->text_factory);

VISIT_CALLBACK_CONTEXT(self->trace_ctx);

VISIT_CALLBACK_CONTEXT(self->progress_ctx);

VISIT_CALLBACK_CONTEXT(self->authorizer_ctx);

#undef VISIT_CALLBACK_CONTEXT

return 0;

}

static inline void

clear_callback_context(callback_context *ctx)

{

if (ctx != NULL) {

Py_CLEAR(ctx->callable);

Py_CLEAR(ctx->module);

}

}

static int

connection_clear(PyObject *op)

{

pysqlite_Connection *self = _pysqlite_Connection_CAST(op);

Py_CLEAR(self->statement_cache);

Py_CLEAR(self->cursors);

Py_CLEAR(self->blobs);

Py_CLEAR(self->row_factory);

Py_CLEAR(self->text_factory);

clear_callback_context(self->trace_ctx);

clear_callback_context(self->progress_ctx);

clear_callback_context(self->authorizer_ctx);

return 0;

}

static void

free_callback_contexts(pysqlite_Connection *self)

{

set_callback_context(&self->trace_ctx, NULL);

set_callback_context(&self->progress_ctx, NULL);

set_callback_context(&self->authorizer_ctx, NULL);

}

static void

remove_callbacks(sqlite3 *db)

{

/* None of these APIs can fail, as long as they are given a valid

assert(db != NULL);

int rc = sqlite3_trace_v2(db, SQLITE_TRACE_STMT, 0, 0);

assert(rc == SQLITE_OK), (void)rc;

sqlite3_progress_handler(db, 0, 0, (void *)0);

rc = sqlite3_set_authorizer(db, NULL, NULL);

assert(rc == SQLITE_OK), (void)rc;

}

static int

connection_close(pysqlite_Connection *self)

{

if (self->db == NULL) {

return 0;

}

int rc = 0;

if (self->autocommit == AUTOCOMMIT_DISABLED &&

!sqlite3_get_autocommit(self->db))

{

if (connection_exec_stmt(self, "ROLLBACK") < 0) {

rc = -1;

}

}

sqlite3 *db = self->db;

self->db = NULL;

Py_BEGIN_ALLOW_THREADS

/* The v2 close call always returns SQLITE_OK if given a valid database

(void)sqlite3_close_v2(db);

Py_END_ALLOW_THREADS

free_callback_contexts(self);

return rc;

}

static void

connection_finalize(PyObject *self)

{

pysqlite_Connection *con = (pysqlite_Connection *)self;

PyObject *exc = PyErr_GetRaisedException();

/* If close is implicitly called as a result of interpreter

PyInterpreterState *interp = PyInterpreterState_Get();

int teardown = _Py_IsInterpreterFinalizing(interp);

if (teardown && con->db) {

remove_callbacks(con->db);

}

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

if (con->db) {

if (PyErr_ResourceWarning(self, 1, "unclosed database in %R", self)) {

/* Spurious errors can appear at shutdown */

if (PyErr_ExceptionMatches(PyExc_Warning)) {

PyErr_FormatUnraisable("Exception ignored while finalizing "

"database connection %R", self);

}

}

}

if (connection_close(con) < 0) {

if (teardown) {

PyErr_Clear();

}

else {

PyErr_FormatUnraisable("Exception ignored while closing database %R",

self);

}

}

PyErr_SetRaisedException(exc);

}

static void

connection_dealloc(PyObject *self)

{

if (PyObject_CallFinalizerFromDealloc(self) < 0) {

return;

}

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(self);

(void)tp->tp_clear(self);

tp->tp_free(self);

Py_DECREF(tp);

}

static PyObject *

pysqlite_connection_cursor_impl(pysqlite_Connection *self, PyObject *factory)

{

PyObject* cursor;

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

return NULL;

}

if (factory == NULL) {

factory = (PyObject *)self->state->CursorType;

}

cursor = PyObject_CallOneArg(factory, (PyObject *)self);

if (cursor == NULL)

return NULL;

if (!PyObject_TypeCheck(cursor, self->state->CursorType)) {

PyErr_Format(PyExc_TypeError,

"factory must return a cursor, not %.100s",

Py_TYPE(cursor)->tp_name);

Py_DECREF(cursor);

return NULL;

}

_pysqlite_drop_unused_cursor_references(self);

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

Py_INCREF(self->row_factory);

Py_XSETREF(((pysqlite_Cursor *)cursor)->row_factory, self->row_factory);

}

return cursor;

}

static PyObject *

blobopen_impl(pysqlite_Connection *self, const char *table, const char *col,

sqlite3_int64 row, int readonly, const char *name)

{

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

return NULL;

}

int rc;

sqlite3_blob *blob;

Py_BEGIN_ALLOW_THREADS

rc = sqlite3_blob_open(self->db, name, table, col, row, !readonly, &blob);

Py_END_ALLOW_THREADS

if (rc == SQLITE_MISUSE) {

set_error_from_code(self->state, rc);

return NULL;

}

else if (rc != SQLITE_OK) {

set_error_from_db(self->state, self->db);

return NULL;

}

pysqlite_Blob *obj = PyObject_GC_New(pysqlite_Blob, self->state->BlobType);

if (obj == NULL) {

goto error;

}

obj->connection = (pysqlite_Connection *)Py_NewRef(self);

obj->blob = blob;

obj->offset = 0;

obj->in_weakreflist = NULL;

PyObject_GC_Track(obj);

// Add our blob to connection blobs list

PyObject *weakref = PyWeakref_NewRef((PyObject *)obj, NULL);

if (weakref == NULL) {

goto error;

}

rc = PyList_Append(self->blobs, weakref);

Py_DECREF(weakref);

if (rc < 0) {

goto error;

}

return (PyObject *)obj;

error:

Py_XDECREF(obj);

return NULL;

}

static PyObject *

pysqlite_connection_close_impl(pysqlite_Connection *self)

{

if (!pysqlite_check_thread(self)) {

return NULL;

}

if (!self->initialized) {

PyTypeObject *tp = Py_TYPE(self);

pysqlite_state *state = pysqlite_get_state_by_type(tp);

PyErr_SetString(state->ProgrammingError,

"Base Connection.__init__ not called.");

return NULL;

}

pysqlite_close_all_blobs(self);

Py_CLEAR(self->statement_cache);

if (connection_close(self) < 0) {

return NULL;

}

Py_RETURN_NONE;

}

int pysqlite_check_connection(pysqlite_Connection* con)

{

if (!con->initialized) {

pysqlite_state *state = pysqlite_get_state_by_type(Py_TYPE(con));

PyErr_SetString(state->ProgrammingError,

"Base Connection.__init__ not called.");

return 0;

}

if (!con->db) {

PyErr_SetString(con->state->ProgrammingError,

"Cannot operate on a closed database.");

return 0;

} else {

return 1;

}

}

static PyObject *

pysqlite_connection_commit_impl(pysqlite_Connection *self)

{

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

return NULL;

}

if (self->autocommit == AUTOCOMMIT_LEGACY) {

if (!sqlite3_get_autocommit(self->db)) {

if (connection_exec_stmt(self, "COMMIT") < 0) {

return NULL;

}

}

}

else if (self->autocommit == AUTOCOMMIT_DISABLED) {

if (connection_exec_stmt(self, "COMMIT") < 0) {

return NULL;

}

if (connection_exec_stmt(self, "BEGIN") < 0) {

return NULL;

}

}

Py_RETURN_NONE;

}

static PyObject *

pysqlite_connection_rollback_impl(pysqlite_Connection *self)

{

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

return NULL;

}

if (self->autocommit == AUTOCOMMIT_LEGACY) {

if (!sqlite3_get_autocommit(self->db)) {

if (connection_exec_stmt(self, "ROLLBACK") < 0) {

return NULL;

}

}

}

else if (self->autocommit == AUTOCOMMIT_DISABLED) {

if (connection_exec_stmt(self, "ROLLBACK") < 0) {

return NULL;

}

if (connection_exec_stmt(self, "BEGIN") < 0) {

return NULL;

}

}

Py_RETURN_NONE;

}

static int

_pysqlite_set_result(sqlite3_context* context, PyObject* py_val)

{

if (py_val == Py_None) {

sqlite3_result_null(context);

} else if (PyLong_Check(py_val)) {

sqlite_int64 value = _pysqlite_long_as_int64(py_val);

if (value == -1 && PyErr_Occurred())

return -1;

sqlite3_result_int64(context, value);

} else if (PyFloat_Check(py_val)) {

double value = PyFloat_AsDouble(py_val);

if (value == -1 && PyErr_Occurred()) {

return -1;

}

sqlite3_result_double(context, value);

} else if (PyUnicode_Check(py_val)) {

Py_ssize_t sz;

const char *str = PyUnicode_AsUTF8AndSize(py_val, &sz);

if (str == NULL) {

return -1;

}

if (sz > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"string is longer than INT_MAX bytes");

return -1;

}

sqlite3_result_text(context, str, (int)sz, SQLITE_TRANSIENT);

} else if (PyObject_CheckBuffer(py_val)) {

Py_buffer view;

if (PyObject_GetBuffer(py_val, &view, PyBUF_SIMPLE) != 0) {

return -1;

}

if (view.len > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"BLOB longer than INT_MAX bytes");

PyBuffer_Release(&view);

return -1;

}

sqlite3_result_blob(context, view.buf, (int)view.len, SQLITE_TRANSIENT);

PyBuffer_Release(&view);

} else {

callback_context *ctx = (callback_context *)sqlite3_user_data(context);

PyErr_Format(ctx->state->ProgrammingError,

"User-defined functions cannot return '%s' values to "

"SQLite",

Py_TYPE(py_val)->tp_name);

return -1;

}

return 0;

}

static 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;

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:

cur_py_value = PyLong_FromLongLong(sqlite3_value_int64(cur_value));

break;

case SQLITE_FLOAT:

cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));

break;

case SQLITE_TEXT: {

sqlite3 *db = sqlite3_context_db_handle(context);

const char *text = (const char *)sqlite3_value_text(cur_value);

if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {

PyErr_NoMemory();

goto error;

}

Py_ssize_t size = sqlite3_value_bytes(cur_value);

cur_py_value = PyUnicode_FromStringAndSize(text, size);

break;

}

case SQLITE_BLOB: {

sqlite3 *db = sqlite3_context_db_handle(context);

const void *blob = sqlite3_value_blob(cur_value);

if (blob == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {

PyErr_NoMemory();

goto error;

}

Py_ssize_t size = sqlite3_value_bytes(cur_value);

cur_py_value = PyBytes_FromStringAndSize(blob, size);

break;

}

case SQLITE_NULL:

default:

cur_py_value = Py_NewRef(Py_None);

}

if (!cur_py_value) {

goto error;

}

PyTuple_SET_ITEM(args, i, cur_py_value);

}

return args;

error:

Py_DECREF(args);

return NULL;

}

static void

print_or_clear_traceback(callback_context *ctx)

{

assert(ctx != NULL);

assert(ctx->state != NULL);

if (ctx->state->enable_callback_tracebacks) {

PyErr_FormatUnraisable("Exception ignored on sqlite3 callback %R",

ctx->callable);

}

else {

PyErr_Clear();

}

}

static void

set_sqlite_error(sqlite3_context *context, const char *msg)

{

assert(PyErr_Occurred());

if (PyErr_ExceptionMatches(PyExc_MemoryError)) {

sqlite3_result_error_nomem(context);

}

else if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

sqlite3_result_error_toobig(context);

}

else {

sqlite3_result_error(context, msg, -1);

}

callback_context *ctx = (callback_context *)sqlite3_user_data(context);

print_or_clear_traceback(ctx);

}

static void

func_callback(sqlite3_context *context, int argc, sqlite3_value **argv)

{

PyGILState_STATE threadstate = PyGILState_Ensure();

PyObject* args;

PyObject* py_retval = NULL;

int ok;

args = _pysqlite_build_py_params(context, argc, argv);

if (args) {

callback_context *ctx = (callback_context *)sqlite3_user_data(context);

assert(ctx != NULL);

py_retval = PyObject_CallObject(ctx->callable, args);

Py_DECREF(args);

}

ok = 0;

if (py_retval) {

ok = _pysqlite_set_result(context, py_retval) == 0;

Py_DECREF(py_retval);

}

if (!ok) {

set_sqlite_error(context, "user-defined function raised exception");

}

PyGILState_Release(threadstate);

}

static void

step_callback(sqlite3_context *context, int argc, sqlite3_value **params)

{

PyGILState_STATE threadstate = PyGILState_Ensure();

PyObject* args;

PyObject* function_result = NULL;

PyObject** aggregate_instance;

PyObject* stepmethod = NULL;

callback_context *ctx = (callback_context *)sqlite3_user_data(context);

assert(ctx != NULL);

aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));

if (aggregate_instance == NULL) {

(void)PyErr_NoMemory();

set_sqlite_error(context, "unable to allocate SQLite aggregate context");

goto error;

}

if (*aggregate_instance == NULL) {

*aggregate_instance = PyObject_CallNoArgs(ctx->callable);

if (!*aggregate_instance) {

set_sqlite_error(context,

"user-defined aggregate's '__init__' method raised error");

goto error;

}

}

stepmethod = PyObject_GetAttr(*aggregate_instance, ctx->state->str_step);

if (!stepmethod) {

set_sqlite_error(context,

"user-defined aggregate's 'step' method not defined");

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) {

set_sqlite_error(context,

"user-defined aggregate's 'step' method raised error");

}