use core::{

ffi::{CStr, c_int, c_longlong, c_uint, c_void},

fmt::Debug,

ops::{Deref, DerefMut},

ptr::{NonNull, null, null_mut},

};

use libsqlite3_sys::{

SQLITE_BLOB, SQLITE_DETERMINISTIC, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL,

SQLITE_OPEN_CREATE, SQLITE_OPEN_FULLMUTEX, SQLITE_OPEN_READWRITE, SQLITE_OPEN_URI,

SQLITE_TEXT, SQLITE_TRACE_STMT, SQLITE_TRANSIENT, SQLITE_UTF8, sqlite3,

sqlite3_aggregate_context, sqlite3_backup_finish, sqlite3_backup_init,

sqlite3_backup_pagecount, sqlite3_backup_remaining, sqlite3_backup_step, sqlite3_bind_blob,

sqlite3_bind_double, sqlite3_bind_int64, sqlite3_bind_null, sqlite3_bind_parameter_count,

sqlite3_bind_parameter_name, sqlite3_bind_text, sqlite3_blob, sqlite3_blob_bytes,

sqlite3_blob_close, sqlite3_blob_open, sqlite3_blob_read, sqlite3_blob_write,

sqlite3_busy_timeout, sqlite3_changes, sqlite3_clear_bindings, sqlite3_column_blob,

sqlite3_column_bytes, sqlite3_column_count, sqlite3_column_decltype, sqlite3_column_double,

sqlite3_column_int64, sqlite3_column_name, sqlite3_column_text, sqlite3_column_type,

sqlite3_complete, sqlite3_context, sqlite3_context_db_handle, sqlite3_create_collation_v2,

sqlite3_create_function_v2, sqlite3_create_window_function, sqlite3_data_count,

sqlite3_db_config, sqlite3_db_handle, sqlite3_db_mutex, sqlite3_errcode, sqlite3_errmsg,

sqlite3_exec, sqlite3_expanded_sql, sqlite3_extended_errcode, sqlite3_finalize,

sqlite3_free, sqlite3_get_autocommit, sqlite3_interrupt, sqlite3_last_insert_rowid,

sqlite3_libversion, sqlite3_limit, sqlite3_mutex_enter, sqlite3_mutex_leave,

sqlite3_mutex_try, sqlite3_open_v2, sqlite3_prepare_v2, sqlite3_progress_handler,

sqlite3_reset, sqlite3_result_blob, sqlite3_result_double, sqlite3_result_error,

sqlite3_result_error_nomem, sqlite3_result_error_toobig, sqlite3_result_int64,

sqlite3_result_null, sqlite3_result_text, sqlite3_set_authorizer, sqlite3_sleep,

sqlite3_step, sqlite3_stmt, sqlite3_stmt_busy, sqlite3_stmt_readonly, sqlite3_threadsafe,

sqlite3_total_changes, sqlite3_trace_v2, sqlite3_user_data, sqlite3_value,

sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_int64,

sqlite3_value_text, sqlite3_value_type,

};

use malachite_bigint::Sign;

use num_traits::ToPrimitive;

use rustpython_common::{

atomic::{Ordering, PyAtomic, Radium},

hash::PyHash,

lock::{PyMappedMutexGuard, PyMutex, PyMutexGuard},

rc::PyRc,

refcount::{try_defer_drop, with_deferred_drops},

static_cell,

};

use rustpython_vm::{

__exports::paste,

AsObject, Py, PyAtomicRef, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,

TryFromBorrowedObject, TryFromObject, VirtualMachine, atomic_func,

builtins::{

PyBaseException, PyBaseExceptionRef, PyByteArray, PyBytes, PyDict, PyDictRef, PyFloat,

PyInt, PyIntRef, PyModule, PySlice, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType,

PyTypeRef, PyUtf8Str, PyUtf8StrRef,

},

function::{

ArgCallable, ArgIntoBool, ArgIntoFloat, ArgIterable, ArgStrOrBytesLike, ArgStrictInt,

FsPath, FuncArgs, KwArgs, OptionalArg, PyComparisonValue, PySetterValue,

},

object::{Traverse, TraverseFn},

protocol::{

PyBuffer, PyIterReturn, PyMappingMethods, PyNumberMethods, PySequence,

PySequenceMethods,

},

sliceable::{SaturatedSliceIter, SliceableSequenceOp},

types::{

AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, Hashable,

Initializer, IterNext, Iterable, PyComparisonOp, SelfIter,

},

utils::ToCString,

};

use std::thread::ThreadId;

macro_rules! exceptions {

($(($x:ident, $base:expr)),*) => {

paste::paste! {

static_cell! {

$(

static [<$x:snake:upper>]: PyTypeRef;

)*

}

$(

#[allow(dead_code)]

fn [<new_ $x:snake>](vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {

vm.new_exception_msg([<$x:snake _type>]().to_owned(), msg.into())

}

fn [<$x:snake _type>]() -> &'static Py<PyType> {

[<$x:snake:upper>].get().expect("exception type not initialize")

}

)*

fn setup_module_exceptions(module: &PyObject, vm: &VirtualMachine) {

$(

#[allow(clippy::redundant_closure_call)]

let exception = [<$x:snake:upper>].get_or_init(|| {

let base = $base(vm);

vm.ctx.new_exception_type("_sqlite3", stringify!($x), Some(vec![base.to_owned()]))

});

module.set_attr(stringify!($x), exception.clone().into_object(), vm).unwrap();

)*

}

}

};

}

exceptions!(

(Warning, |vm: &VirtualMachine| vm

.ctx

.exceptions

.exception_type),

(Error, |vm: &VirtualMachine| vm

.ctx

.exceptions

.exception_type),

(InterfaceError, |_| error_type()),

(DatabaseError, |_| error_type()),

(DataError, |_| database_error_type()),

(OperationalError, |_| database_error_type()),

(IntegrityError, |_| database_error_type()),

(InternalError, |_| database_error_type()),

(ProgrammingError, |_| database_error_type()),

(NotSupportedError, |_| database_error_type())

);

#[pyattr]

fn sqlite_version(vm: &VirtualMachine) -> String {

let s = unsafe { sqlite3_libversion() };

ptr_to_str(s, vm).unwrap().to_owned()

}

#[pyattr]

fn threadsafety(_: &VirtualMachine) -> c_int {

let mode = unsafe { sqlite3_threadsafe() };

match mode {

0 => 0,

1 => 3,

2 => 1,

_ => panic!("Unable to interpret SQLite threadsafety mode"),

}

}

#[pyattr(name = "_deprecated_version")]

const PYSQLITE_VERSION: &str = "2.6.0";

#[pyattr]

const PARSE_DECLTYPES: c_int = 1;

#[pyattr]

const PARSE_COLNAMES: c_int = 2;

#[pyattr]

const LEGACY_TRANSACTION_CONTROL: c_int = -1;

#[pyattr]

use libsqlite3_sys::{

SQLITE_ALTER_TABLE, SQLITE_ANALYZE, SQLITE_ATTACH, SQLITE_CREATE_INDEX,

SQLITE_CREATE_TABLE, SQLITE_CREATE_TEMP_INDEX, SQLITE_CREATE_TEMP_TABLE,

SQLITE_CREATE_TEMP_TRIGGER, SQLITE_CREATE_TEMP_VIEW, SQLITE_CREATE_TRIGGER,

SQLITE_CREATE_VIEW, SQLITE_CREATE_VTABLE, SQLITE_DBCONFIG_DEFENSIVE,

SQLITE_DBCONFIG_DQS_DDL, SQLITE_DBCONFIG_DQS_DML, SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE,

SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE, SQLITE_DBCONFIG_ENABLE_COMMENTS,

SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER,

SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_DBCONFIG_ENABLE_QPSG,

SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_DBCONFIG_ENABLE_VIEW,

SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, SQLITE_DBCONFIG_LEGACY_FILE_FORMAT,

SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_DBCONFIG_RESET_DATABASE,

SQLITE_DBCONFIG_REVERSE_SCANORDER, SQLITE_DBCONFIG_STMT_SCANSTATUS,

SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_DBCONFIG_TRUSTED_SCHEMA,

SQLITE_DBCONFIG_WRITABLE_SCHEMA, SQLITE_DELETE, SQLITE_DENY, SQLITE_DETACH,

SQLITE_DROP_INDEX, SQLITE_DROP_TABLE, SQLITE_DROP_TEMP_INDEX, SQLITE_DROP_TEMP_TABLE,

SQLITE_DROP_TEMP_TRIGGER, SQLITE_DROP_TEMP_VIEW, SQLITE_DROP_TRIGGER, SQLITE_DROP_VIEW,

SQLITE_DROP_VTABLE, SQLITE_FUNCTION, SQLITE_IGNORE, SQLITE_INSERT, SQLITE_LIMIT_ATTACHED,

SQLITE_LIMIT_COLUMN, SQLITE_LIMIT_COMPOUND_SELECT, SQLITE_LIMIT_EXPR_DEPTH,

SQLITE_LIMIT_FUNCTION_ARG, SQLITE_LIMIT_LENGTH, SQLITE_LIMIT_LIKE_PATTERN_LENGTH,

SQLITE_LIMIT_SQL_LENGTH, SQLITE_LIMIT_TRIGGER_DEPTH, SQLITE_LIMIT_VARIABLE_NUMBER,

SQLITE_LIMIT_VDBE_OP, SQLITE_LIMIT_WORKER_THREADS, SQLITE_PRAGMA, SQLITE_READ,

SQLITE_RECURSIVE, SQLITE_REINDEX, SQLITE_SAVEPOINT, SQLITE_SELECT, SQLITE_TRANSACTION,

SQLITE_UPDATE,

};

macro_rules! error_codes {

($($x:ident),*) => {

$(

#[allow(unused_imports)]

use libsqlite3_sys::$x;

)*

static ERROR_CODES: &[(&str, c_int)] = &[

$(

(stringify!($x), libsqlite3_sys::$x),

)*

];

};

}

error_codes!(

SQLITE_ABORT,

SQLITE_AUTH,

SQLITE_BUSY,

SQLITE_CANTOPEN,

SQLITE_CONSTRAINT,

SQLITE_CORRUPT,

SQLITE_DONE,

SQLITE_EMPTY,

SQLITE_ERROR,

SQLITE_FORMAT,

SQLITE_FULL,

SQLITE_INTERNAL,

SQLITE_INTERRUPT,

SQLITE_IOERR,

SQLITE_LOCKED,

SQLITE_MISMATCH,

SQLITE_MISUSE,

SQLITE_NOLFS,

SQLITE_NOMEM,

SQLITE_NOTADB,

SQLITE_NOTFOUND,

SQLITE_OK,

SQLITE_PERM,

SQLITE_PROTOCOL,

SQLITE_RANGE,

SQLITE_READONLY,

SQLITE_ROW,

SQLITE_SCHEMA,

SQLITE_TOOBIG,

SQLITE_NOTICE,

SQLITE_WARNING,

SQLITE_ABORT_ROLLBACK,

SQLITE_BUSY_RECOVERY,

SQLITE_CANTOPEN_FULLPATH,

SQLITE_CANTOPEN_ISDIR,

SQLITE_CANTOPEN_NOTEMPDIR,

SQLITE_CORRUPT_VTAB,

SQLITE_IOERR_ACCESS,

SQLITE_IOERR_BLOCKED,

SQLITE_IOERR_CHECKRESERVEDLOCK,

SQLITE_IOERR_CLOSE,

SQLITE_IOERR_DELETE,

SQLITE_IOERR_DELETE_NOENT,

SQLITE_IOERR_DIR_CLOSE,

SQLITE_IOERR_DIR_FSYNC,

SQLITE_IOERR_FSTAT,

SQLITE_IOERR_FSYNC,

SQLITE_IOERR_LOCK,

SQLITE_IOERR_NOMEM,

SQLITE_IOERR_RDLOCK,

SQLITE_IOERR_READ,

SQLITE_IOERR_SEEK,

SQLITE_IOERR_SHMLOCK,

SQLITE_IOERR_SHMMAP,

SQLITE_IOERR_SHMOPEN,

SQLITE_IOERR_SHMSIZE,

SQLITE_IOERR_SHORT_READ,

SQLITE_IOERR_TRUNCATE,

SQLITE_IOERR_UNLOCK,

SQLITE_IOERR_WRITE,

SQLITE_LOCKED_SHAREDCACHE,

SQLITE_READONLY_CANTLOCK,

SQLITE_READONLY_RECOVERY,

SQLITE_CONSTRAINT_CHECK,

SQLITE_CONSTRAINT_COMMITHOOK,

SQLITE_CONSTRAINT_FOREIGNKEY,

SQLITE_CONSTRAINT_FUNCTION,

SQLITE_CONSTRAINT_NOTNULL,

SQLITE_CONSTRAINT_PRIMARYKEY,

SQLITE_CONSTRAINT_TRIGGER,

SQLITE_CONSTRAINT_UNIQUE,

SQLITE_CONSTRAINT_VTAB,

SQLITE_READONLY_ROLLBACK,

SQLITE_IOERR_MMAP,

SQLITE_NOTICE_RECOVER_ROLLBACK,

SQLITE_NOTICE_RECOVER_WAL,

SQLITE_BUSY_SNAPSHOT,

SQLITE_IOERR_GETTEMPPATH,

SQLITE_WARNING_AUTOINDEX,

SQLITE_CANTOPEN_CONVPATH,

SQLITE_IOERR_CONVPATH,

SQLITE_CONSTRAINT_ROWID,

SQLITE_READONLY_DBMOVED,

SQLITE_AUTH_USER,

SQLITE_OK_LOAD_PERMANENTLY,

SQLITE_IOERR_VNODE,

SQLITE_IOERR_AUTH,

SQLITE_IOERR_BEGIN_ATOMIC,

SQLITE_IOERR_COMMIT_ATOMIC,

SQLITE_IOERR_ROLLBACK_ATOMIC,

SQLITE_ERROR_MISSING_COLLSEQ,

SQLITE_ERROR_RETRY,

SQLITE_READONLY_CANTINIT,

SQLITE_READONLY_DIRECTORY,

SQLITE_CORRUPT_SEQUENCE,

SQLITE_LOCKED_VTAB,

SQLITE_CANTOPEN_DIRTYWAL,

SQLITE_ERROR_SNAPSHOT,

SQLITE_CANTOPEN_SYMLINK,

SQLITE_CONSTRAINT_PINNED,

SQLITE_OK_SYMLINK,

SQLITE_BUSY_TIMEOUT,

SQLITE_CORRUPT_INDEX,

SQLITE_IOERR_DATA,

SQLITE_IOERR_CORRUPTFS

);

/// Autocommit mode setting for sqlite3 connections.

/// - Legacy (default): use isolation_level to control transactions

/// - Enabled: autocommit mode (no automatic transactions)

/// - Disabled: manual commit mode

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]

enum AutocommitMode {

#[default]

Legacy,

Enabled,

Disabled,

}

impl TryFromBorrowedObject<'_> for AutocommitMode {

fn try_from_borrowed_object(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Self> {

if obj.is(&vm.ctx.true_value) {

Ok(Self::Enabled)

} else if obj.is(&vm.ctx.false_value) {

Ok(Self::Disabled)

} else if obj

.downcast_ref::<PyInt>()

.is_some_and(|value| value.as_bigint() == &LEGACY_TRANSACTION_CONTROL.into())

{

Ok(Self::Legacy)

} else {

Err(vm.new_value_error(

"autocommit must be True, False, or sqlite3.LEGACY_TRANSACTION_CONTROL",

))

}

}

}

// Validate Clinic's str arguments while binding, before later conversions.

// Retain the original str so subclasses cannot finalize during conversion.

struct SqliteStringArg {

value: alloc::ffi::CString,

owner: PyUtf8StrRef,

}

impl TryFromObject for SqliteStringArg {

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

let owner = PyUtf8StrRef::try_from_object(vm, obj)?;

let value = owner.to_cstring(vm)?;

Ok(Self { value, owner })

}

}

impl Deref for SqliteStringArg {

type Target = CStr;

fn deref(&self) -> &CStr {

&self.value

}

}

unsafe impl Traverse for SqliteStringArg {

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {

self.owner.traverse(tracer_fn);

}

}

struct IsolationLevelArg(Option<PyStrRef>);

impl TryFromObject for IsolationLevelArg {

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

if vm.is_none(&obj) {

return Ok(Self(None));

}

obj.downcast::<PyStr>()

.map_err(|_| vm.new_type_error("isolation_level must be str or None".to_owned()))

.and_then(|s| {

s.try_as_utf8(vm)?;

if s.contains_nuls() {

Err(vm.new_value_error("isolation_level contains interior NULs".to_owned()))

} else {

begin_statement_ptr_from_isolation_level(&s, vm)?;

Ok(Self(Some(

vm.ctx.new_str(s.expect_str().to_ascii_uppercase()),

)))

}

})

}

}

#[derive(FromArgs)]

struct ConnectArgs {

#[pyarg(any)]

database: PyObjectRef,

#[pyarg(named, default = 5.0)]

timeout: ArgIntoFloat,

#[pyarg(named, default = 0)]

detect_types: c_int,

#[pyarg(named, default = "")]

isolation_level: IsolationLevelArg,

#[pyarg(named, default = ArgIntoBool::TRUE)]

check_same_thread: ArgIntoBool,

#[pyarg(named, default = Connection::class(&vm.ctx).to_owned().into_object(), py_default = "ConnectionType")]

factory: PyObjectRef,

#[pyarg(named, default = 128)]

cached_statements: c_int,

#[pyarg(named, default = ArgIntoBool::FALSE)]

uri: ArgIntoBool,

#[pyarg(named, default)]

autocommit: AutocommitMode,

}

unsafe impl Traverse for ConnectArgs {

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {

self.database.traverse(tracer_fn);

self.isolation_level.0.traverse(tracer_fn);

self.factory.traverse(tracer_fn);

}

}

#[derive(FromArgs)]

struct BackupArgs {

#[pyarg(any)]

target: PyRef<Connection>,

#[pyarg(named, default = -1)]

pages: c_int,

#[pyarg(named, optional)]

progress: Option<PyObjectRef>,

#[pyarg(named, default = "main")]

name: SqliteStringArg,

#[pyarg(named, default = 0.250)]

sleep: ArgIntoFloat,

}

unsafe impl Traverse for BackupArgs {

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {

self.progress.traverse(tracer_fn);

self.name.traverse(tracer_fn);

}

}

#[derive(FromArgs)]

struct IterDumpArgs {

#[pyarg(named, optional)]

filter: Option<PyStrRef>,

}

#[derive(FromArgs)]

struct DatabaseNameArgs {

#[pyarg(named, default = "main")]

name: SqliteStringArg,

}

#[derive(FromArgs)]

struct DeserializeArgs {

#[pyarg(positional)]

data: ArgStrOrBytesLike,

#[pyarg(named, default = "main")]

name: PyStrRef,

}

#[derive(FromArgs)]

struct CreateFunctionArgs {

#[pyarg(positional)]

name: SqliteStringArg,

#[pyarg(positional)]

narg: c_int,

#[pyarg(positional)]

func: PyObjectRef,

#[pyarg(named, default = ArgIntoBool::FALSE)]

deterministic: ArgIntoBool,

}

#[derive(FromArgs)]

struct CreateAggregateArgs {

#[pyarg(positional)]

name: SqliteStringArg,

#[pyarg(positional)]

n_arg: c_int,

#[pyarg(positional)]

aggregate_class: PyObjectRef,

}

#[derive(FromArgs)]

struct CompleteStatementArgs {

#[pyarg(any)]

statement: SqliteStringArg,

}

#[derive(FromArgs)]

struct ExecuteArgs {

#[pyarg(positional)]

sql: PyUtf8StrRef,

#[pyarg(positional, optional, py_default = "()")]

parameters: OptionalArg<PyObjectRef>,

}

#[derive(FromArgs)]

struct SetProgressHandlerArgs {

#[pyarg(positional)]

progress_handler: PyObjectRef,

#[pyarg(any)]

n: c_int,

}

#[derive(FromArgs)]

struct SetConfigArgs {

#[pyarg(positional)]

op: c_int,

#[pyarg(positional, default = ArgIntoBool::TRUE)]

enable: ArgIntoBool,

}

#[derive(FromArgs)]

struct BlobOpenArgs {

#[pyarg(positional)]

table: SqliteStringArg,

#[pyarg(positional)]

column: SqliteStringArg,

#[pyarg(positional)]

rowid: ArgStrictInt<i64>,

#[pyarg(named, default = ArgIntoBool::FALSE)]

readonly: ArgIntoBool,

#[pyarg(named, default = "main")]

name: SqliteStringArg,

}

#[derive(FromArgs)]

struct CursorArgs {

#[pyarg(any, default)]

factory: OptionalArg<PyObjectRef>,

}

struct CallbackData {

obj: NonNull<PyObject>,

}

impl CallbackData {

fn new(obj: PyObjectRef, vm: &VirtualMachine) -> Option<Self> {

(!vm.is_none(&obj)).then_some(Self {

obj: obj.into_raw(),

})

}

fn with_vm<R>(&self, f: impl Fn(&PyObject, &VirtualMachine) -> R) -> Option<R> {

let obj = unsafe { self.obj.as_ref() };

// A shared connection may invoke this callback on a different thread

// after the registering thread's VM has already been destroyed.

rustpython_vm::vm::thread::with_vm(obj, |vm| f(obj, vm))

}

fn report_exception(callable: &PyObject, exc: PyBaseExceptionRef) {

if !enable_traceback().load(Ordering::Relaxed) {

return;

}

let callable = callable.to_owned();

// Both repr() and sys.unraisablehook can re-enter SQLite. The

// surrounding operation releases its cursor/statement locks first.

try_defer_drop(move || {

rustpython_vm::vm::thread::with_vm(&callable, |vm| {

let message = callable.repr(vm).ok().map(|repr| {

format!(

"Exception ignored on sqlite3 callback {}",

repr.to_string_lossy()

)

});

vm.run_unraisable(exc.clone(), message, vm.ctx.none());

});

});

}

// The SQLite mutex keeps the registration alive until this reference is acquired.

unsafe fn registered(data: *mut c_void) -> PyRc<Self> {

let data = data.cast::<Self>();

unsafe {

PyRc::increment_strong_count(data);

PyRc::from_raw(data)

}

}

fn with_context(&self, context: SqliteContext, f: impl Fn(&PyObject, &VirtualMachine)) {

if self.with_vm(f).is_none() {

unsafe {

sqlite3_result_error(

context.ctx,

c"SQLite callback has no active interpreter".as_ptr(),

-1,

)

};

}

}

unsafe extern "C" fn destructor(data: *mut c_void) {

drop(unsafe { Box::from_raw(data.cast::<Self>()) });

}

unsafe extern "C" fn func_callback(

context: *mut sqlite3_context,

argc: c_int,

argv: *mut *mut sqlite3_value,

) {

let context = SqliteContext::from(context);

let data = unsafe { &*context.user_data::<Self>() };

data.with_context(context, |func, vm| {

let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };

let f = || -> PyResult<()> {

let db = context.db_handle();

let args = args

.iter()

.copied()

.map(|val| value_to_object(val, db, vm))

.collect::<PyResult<Vec<PyObjectRef>>>()?;

let val = func.call(args, vm)?;

context.result_from_object(&val, vm)

};

if let Err(exc) = f() {

context.result_exception(vm, exc, c"user-defined function raised exception")

}

});

}

unsafe extern "C" fn step_callback(

context: *mut sqlite3_context,

argc: c_int,

argv: *mut *mut sqlite3_value,

) {

let context = SqliteContext::from(context);

let data = unsafe { &*context.user_data::<Self>() };

data.with_context(context, |cls, vm| {

let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };

let instance = context.aggregate_context(true);

if instance.is_null() {

unsafe { sqlite3_result_error_nomem(context.ctx) };

return;

}

if unsafe { (*instance).is_null() } {

match cls.call((), vm) {

Ok(obj) => unsafe { *instance = obj.into_raw().as_ptr() },

Err(exc) => {

return context.result_exception(

vm,

exc,

c"user-defined aggregate's '__init__' method raised error",

);

}

}

}

let instance = unsafe { &**instance };

Self::call_method_with_args(context, instance, "step", args, vm);

});

}

unsafe extern "C" fn finalize_callback(context: *mut sqlite3_context) {

let context = SqliteContext::from(context);

let data = unsafe { &*context.user_data::<Self>() };

let instance = context.aggregate_context(false);

if instance.is_null() {

return;

}

// xFinal releases the reference acquired by xStep, even if the

// query or finalize() fails. Clear the slot before calling Python.

let object = unsafe { instance.replace(core::ptr::null()) };

let Some(object) = NonNull::new(object.cast_mut()) else {

return;

};

let instance = unsafe { PyObjectRef::from_raw(object) };

data.with_context(context, |_, vm| {

Self::callback_result_from_method(context, &instance, "finalize", vm);

});

// __del__ and weakref callbacks must run after the caller releases

// its cursor, statement and connection locks.

try_defer_drop(move || drop(instance));

}

unsafe extern "C" fn collation_callback(

data: *mut c_void,

a_len: c_int,

a_ptr: *const c_void,

b_len: c_int,

b_ptr: *const c_void,

) -> c_int {

let data = unsafe { &*data.cast::<Self>() };

data.with_vm(|callable, vm| {

let f = || -> PyResult<c_int> {

let text1 = ptr_to_string(a_ptr.cast(), a_len, null_mut(), vm)?;

let text1 = vm.ctx.new_str(text1);

let text2 = ptr_to_string(b_ptr.cast(), b_len, null_mut(), vm)?;

let text2 = vm.ctx.new_str(text2);

let val = callable.call((text1, text2), vm)?;

let Some(val) = val.number().index(vm) else {

return Ok(0);

};

let val = match val?.as_bigint().sign() {

Sign::Plus => 1,

Sign::Minus => -1,

Sign::NoSign => 0,

};

Ok(val)

};

f().unwrap_or(0)

})

.unwrap_or(0)

}

unsafe extern "C" fn value_callback(context: *mut sqlite3_context) {

let context = SqliteContext::from(context);

let data = unsafe { &*context.user_data::<Self>() };

data.with_context(context, |_, vm| {

let instance = context.aggregate_context(false);

let Some(instance) = (unsafe { instance.as_ref().and_then(|obj| obj.as_ref()) })

else {

return;

};

Self::callback_result_from_method(context, instance, "value", vm);

});

}

unsafe extern "C" fn inverse_callback(

context: *mut sqlite3_context,

argc: c_int,

argv: *mut *mut sqlite3_value,

) {

let context = SqliteContext::from(context);

let data = unsafe { &*context.user_data::<Self>() };

data.with_context(context, |_, vm| {

let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };

let instance = context.aggregate_context(false);

let Some(instance) = (unsafe { instance.as_ref().and_then(|obj| obj.as_ref()) })

else {

return;

};

Self::call_method_with_args(context, instance, "inverse", args, vm);

});

}

unsafe extern "C" fn authorizer_callback(

data: *mut c_void,

action: c_int,

arg1: *const libc::c_char,

arg2: *const libc::c_char,

db_name: *const libc::c_char,

access: *const libc::c_char,

) -> c_int {

let data = unsafe { Self::registered(data) };

data.with_vm(|callable, vm| {

let f = || -> PyResult<c_int> {

let arg1 = ptr_to_str_or_none(arg1, vm)?;

let arg2 = ptr_to_str_or_none(arg2, vm)?;

let db_name = ptr_to_str_or_none(db_name, vm)?;

let access = ptr_to_str_or_none(access, vm)?;

let val = callable.call((action, arg1, arg2, db_name, access), vm)?;

let Some(val) = val.downcast_ref::<PyInt>() else {

return Ok(SQLITE_DENY);

};

val.try_to_primitive::<c_int>(vm)

};

f().unwrap_or_else(|exc| {

Self::report_exception(callable, exc);

SQLITE_DENY

})

})

.unwrap_or(SQLITE_DENY)

}

unsafe extern "C" fn trace_callback(

_typ: c_uint,

data: *mut c_void,

stmt: *mut c_void,

sql: *mut c_void,

) -> c_int {

let data = unsafe { Self::registered(data) };

data.with_vm(|callable, vm| {

let f = || -> PyResult<()> {

let stmt = {

let expanded = scopeguard::guard(

unsafe { sqlite3_expanded_sql(stmt.cast()) },

|sql| unsafe { sqlite3_free(sql.cast()) },

);

let text = if expanded.is_null() {

let db = unsafe { sqlite3_db_handle(stmt.cast()) };

if unsafe { sqlite3_errcode(db) } == SQLITE_NOMEM {

return Err(vm.new_memory_error(""));

}

Self::report_exception(

callable,

vm.new_exception_msg(

data_error_type().to_owned(),

"Expanded SQL string exceeds the maximum string length".into(),

),

);

ptr_to_str(sql.cast(), vm)?

} else {

ptr_to_str(*expanded, vm)?

};

vm.ctx.new_str(text)

};

callable.call((stmt,), vm)?;

Ok(())

};

if let Err(exc) = f() {

Self::report_exception(callable, exc);

}

0

})

.unwrap_or(0)

}

unsafe extern "C" fn progress_callback(data: *mut c_void) -> c_int {

let data = unsafe { Self::registered(data) };

data.with_vm(|callable, vm| {

match callable.call((), vm).and_then(|val| val.is_true(vm)) {

Ok(val) => val as c_int,

Err(exc) => {

Self::report_exception(callable, exc);

-1

}

}

})

.unwrap_or(-1)

}

fn callback_result_from_method(

context: SqliteContext,

instance: &PyObject,

name: &str,

vm: &VirtualMachine,

) {

let f = || -> PyResult<()> {

let val = vm.call_method(instance, name, ())?;

context.result_from_object(&val, vm)

};

if let Err(exc) = f() {

if exc.fast_isinstance(vm.ctx.exceptions.attribute_error) {

context.result_exception(

vm,

exc,

CStr::from_bytes_until_nul(

format!("user-defined aggregate's '{name}' method not defined\0")

.as_bytes(),

)

.unwrap(),

)

} else {

context.result_exception(

vm,

exc,

CStr::from_bytes_until_nul(

format!("user-defined aggregate's '{name}' method raised error\0")

.as_bytes(),

)

.unwrap(),