Add PHPUnit tests workflow for Turso DB

.github/turso-patches/01-stub-macro.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""
+Neutralize Turso's stub! macro (sqlite3/src/lib.rs).
+
+Many SQLite C API functions are stubbed out via `stub!()`, which expands
+to `todo!("X is not implemented")`. pdo_sqlite hits one during PDO
+construction (sqlite3_set_authorizer) and the panic aborts the PHP
+process. Rewrite the body to return a zeroed value of the function's
+return type (0 / SQLITE_OK for ints, NULL for pointers) instead.
+"""
+
+import sys
+
+PATH = 'sqlite3/src/lib.rs'
+OLD = 'todo!("{} is not implemented", stringify!($fn));'
+NEW = 'return unsafe { std::mem::zeroed() };'
+
+with open(PATH) as f:
+    src = f.read()
+if OLD not in src:
+    sys.exit(f'{PATH}: stub! todo!() body not found')
+n = src.count(OLD)
+src = src.replace(OLD, NEW)
+with open(PATH, 'w') as f:
+    f.write(src)
+print(f'patched stub! macro ({n} occurrence{"s" if n != 1 else ""})')

.github/turso-patches/02-column-functions-null-row.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+sqlite3_column_* — early-return when no row is present (sqlite3/src/lib.rs).
+
+The sqlite3_column_* functions `.expect()` that a row is present, but
+pdo_sqlite legitimately calls them on statements that have not yet
+stepped to SQLITE_ROW (e.g. for column metadata). Replace the expect
+with an early return of the type's "null" value, matching SQLite's
+actual behaviour.
+"""
+
+import re
+import sys
+
+PATH = 'sqlite3/src/lib.rs'
+
+DEFAULTS = {
+    'sqlite3_column_type':   'SQLITE_NULL',
+    'sqlite3_column_int':    '0',
+    'sqlite3_column_int64':  '0',
+    'sqlite3_column_double': '0.0',
+    'sqlite3_column_blob':   'std::ptr::null()',
+    'sqlite3_column_bytes':  '0',
+    'sqlite3_column_text':   'std::ptr::null()',
+}
+
+PATTERN = re.compile(
+    r'(pub unsafe extern "C" fn (sqlite3_column_\w+)\([^)]*\)[^{]*\{)'
+    r'((?:[^{}]|\{[^{}]*\})*?)'
+    r'(let row = stmt\s*\.stmt\s*\.row\(\)\s*'
+    r'\.expect\("Function should only be called after `SQLITE_ROW`"\);)',
+    re.DOTALL,
+)
+
+
+def repl(m):
+    header, name, body, _ = m.group(1), m.group(2), m.group(3), m.group(4)
+    default = DEFAULTS.get(name, '0')
+    guarded = (
+        f'let row = match stmt.stmt.row() {{ '
+        f'Some(r) => r, None => return {default} }};'
+    )
+    return header + body + guarded
+
+
+with open(PATH) as f:
+    src = f.read()
+src, n = PATTERN.subn(repl, src)
+if n == 0:
+    sys.exit(f'{PATH}: no sqlite3_column_* expect-row blocks matched')
+with open(PATH, 'w') as f:
+    f.write(src)
+print(f'patched {n} sqlite3_column_* functions')

.github/turso-patches/03-text-blob-free-types.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+TextValue::free / Blob::free — rebuild the original slice box (extensions/core/src/types.rs).
+
+TextValue/Blob `free` reconstructs `Box<u8>` from a pointer that was
+originally `Box<str>` / `Box<[u8]>` (fat pointers, length lost in the
+cast). This corrupts the heap when custom UDFs return text/blob values.
+Fix both frees to use the stored length and rebuild the correct slice
+box.
+"""
+
+import re
+import sys
+
+PATH = 'extensions/core/src/types.rs'
+
+OLD_TEXT = (
+    '    #[cfg(feature = "core_only")]\n'
+    '    fn free(self) {\n'
+    '        if !self.text.is_null() {\n'
+    '            let _ = unsafe { Box::from_raw(self.text as *mut u8) };\n'
+    '        }\n'
+    '    }\n'
+)
+NEW_TEXT = (
+    '    #[cfg(feature = "core_only")]\n'
+    '    fn free(self) {\n'
+    '        if !self.text.is_null() && self.len > 0 {\n'
+    '            unsafe {\n'
+    '                let slice = std::slice::from_raw_parts_mut(\n'
+    '                    self.text as *mut u8, self.len as usize);\n'
+    '                let _ = Box::from_raw(slice as *mut [u8]);\n'
+    '            }\n'
+    '        }\n'
+    '    }\n'
+)
+
+with open(PATH) as f:
+    s = f.read()
+if OLD_TEXT not in s:
+    sys.exit(f'{PATH}: TextValue::free not found')
+s = s.replace(OLD_TEXT, NEW_TEXT, 1)
+
+# Blob::free uses the same pattern.
+blob_pat = re.compile(
+    r'(impl Blob \{\n(?:[^}]|\{[^}]*\})*?)'
+    r'(    #\[cfg\(feature = "core_only"\)\]\n'
+    r'    fn free\(self\) \{\n'
+    r'        if !self\.data\.is_null\(\) \{\n'
+    r'            let _ = unsafe \{ Box::from_raw\(self\.data as \*mut u8\) \};\n'
+    r'        \}\n'
+    r'    \}\n)'
+)
+m = blob_pat.search(s)
+if m:
+    new_blob = (
+        '    #[cfg(feature = "core_only")]\n'
+        '    fn free(self) {\n'
+        '        if !self.data.is_null() && self.size > 0 {\n'
+        '            unsafe {\n'
+        '                let slice = std::slice::from_raw_parts_mut(\n'
+        '                    self.data as *mut u8, self.size as usize);\n'
+        '                let _ = Box::from_raw(slice as *mut [u8]);\n'
+        '            }\n'
+        '        }\n'
+        '    }\n'
+    )
+    s = s[:m.start(2)] + new_blob + s[m.end(2):]
+    print('patched Blob::free')
+
+with open(PATH, 'w') as f:
+    f.write(s)
+print('patched TextValue::free')

.github/turso-patches/04-create-function-v2-skip-old-destroy.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+create_function_v2 — don't fire the old destroy callback on slot reuse (sqlite3/src/lib.rs).
+
+Turso's create_function_v2 invokes the previous FuncSlot's destroy
+callback when re-registering a UDF with the same name. In practice
+(PHPUnit) this means:
+  - setUp #1 opens PDO A, registers 44 UDFs, each with a destroy
+    callback + p_app pointing to A.
+  - tearDown closes PDO A — Turso's sqlite3_close doesn't clear those
+    FuncSlots.
+  - setUp #2 opens PDO B, re-registers the same 44 names. Turso invokes
+    the OLD destroy callback with the now-dangling A p_app, which trips
+    pdo_sqlite and hangs the process.
+
+Comment the destroy invocation out; the callbacks still fire at real
+PDO-destruction time from the PHP side.
+"""
+
+import sys
+
+PATH = 'sqlite3/src/lib.rs'
+OLD = (
+    '        // Reuse existing slot — invoke old destroy callback on old user data.\n'
+    '        if let Some(old) = slots[id].take() {\n'
+    '            if old.destroy != 0 {\n'
+    '                let old_destroy: unsafe extern "C" fn(*mut ffi::c_void) =\n'
+    '                    std::mem::transmute(old.destroy);\n'
+    '                old_destroy(old.p_app as *mut ffi::c_void);\n'
+    '            }\n'
+    '        }\n'
+)
+NEW = (
+    "        // Don't invoke the old destroy callback here — in PDO\n"
+    "        // usage the previous slot's p_app often belongs to a db\n"
+    '        // that has already been closed, so the callback UAFs.\n'
+    '        let _ = slots[id].take();\n'
+)
+
+with open(PATH) as f:
+    s = f.read()
+if OLD not in s:
+    sys.exit(f'{PATH}: slot destroy block not found')
+with open(PATH, 'w') as f:
+    f.write(s.replace(OLD, NEW, 1))
+print('patched slot-reuse destroy invocation')

.github/turso-patches/05-finalize-try-lock-on-gc-reentry.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""
+sqlite3_finalize / stmt_run_to_completion — try_lock to dodge GC re-entry deadlock.
+
+sqlite3_finalize uses a non-reentrant std::sync::Mutex on the db. PHP's
+cycle GC can fire a PDO statement destructor while another statement's
+sqlite3_step is in progress (i.e., from inside a UDF callback whose
+bridge re-enters PHP). The outer step holds the mutex, the inner
+finalize blocks on it, and we deadlock.
+
+Fix: use try_lock; on contention, skip the stmt_list unlink and the
+drain. The list is only traversed by sqlite3_next_stmt (which
+pdo_sqlite doesn't call) and dropped on sqlite3_close, so a stale entry
+is harmless; the stmt's own Box is still freed below.
+"""
+
+import sys
+
+PATH = 'sqlite3/src/lib.rs'
+
+OLD_FINALIZE = (
+    '    if !stmt_ref.db.is_null() {\n'
+    '        let db = &mut *stmt_ref.db;\n'
+    '        let mut db_inner = db.inner.lock().unwrap();\n'
+    '\n'
+    '        if db_inner.stmt_list == stmt {\n'
+    '            db_inner.stmt_list = stmt_ref.next;\n'
+    '        } else {\n'
+    '            let mut current = db_inner.stmt_list;\n'
+    '            while !current.is_null() {\n'
+    '                let current_ref = &mut *current;\n'
+    '                if current_ref.next == stmt {\n'
+    '                    current_ref.next = stmt_ref.next;\n'
+    '                    break;\n'
+    '                }\n'
+    '                current = current_ref.next;\n'
+    '            }\n'
+    '        }\n'
+    '    }\n'
+)
+NEW_FINALIZE = (
+    '    if !stmt_ref.db.is_null() {\n'
+    '        let db = &mut *stmt_ref.db;\n'
+    '        // try_lock to avoid deadlock when finalize is invoked\n'
+    '        // re-entrantly (GC destructor during UDF callback).\n'
+    '        if let Ok(mut db_inner) = db.inner.try_lock() {\n'
+    '            if db_inner.stmt_list == stmt {\n'
+    '                db_inner.stmt_list = stmt_ref.next;\n'
+    '            } else {\n'
+    '                let mut current = db_inner.stmt_list;\n'
+    '                while !current.is_null() {\n'
+    '                    let current_ref = &mut *current;\n'
+    '                    if current_ref.next == stmt {\n'
+    '                        current_ref.next = stmt_ref.next;\n'
+    '                        break;\n'
+    '                    }\n'
+    '                    current = current_ref.next;\n'
+    '                }\n'
+    '            }\n'
+    '        }\n'
+    '    }\n'
+)
+
+OLD_DRAIN = (
+    'unsafe fn stmt_run_to_completion(stmt: *mut sqlite3_stmt) -> ffi::c_int {\n'
+    '    let stmt_ref = &mut *stmt;\n'
+    '    while stmt_ref.stmt.execution_state().is_running() {\n'
+    '        let result = sqlite3_step(stmt);\n'
+    '        if result != SQLITE_DONE && result != SQLITE_ROW {\n'
+    '            return result;\n'
+    '        }\n'
+    '    }\n'
+    '    SQLITE_OK\n'
+    '}\n'
+)
+NEW_DRAIN = (
+    'unsafe fn stmt_run_to_completion(stmt: *mut sqlite3_stmt) -> ffi::c_int {\n'
+    '    let stmt_ref = &mut *stmt;\n'
+    "    // Skip drain if we can't acquire the db mutex: we're\n"
+    "    // re-entering from a UDF callback's GC destructor, and\n"
+    '    // sqlite3_step would block forever. The stmt will be\n'
+    '    // freed anyway by the caller.\n'
+    '    if !stmt_ref.db.is_null() {\n'
+    '        let db = &*stmt_ref.db;\n'
+    '        if db.inner.try_lock().is_err() {\n'
+    '            return SQLITE_OK;\n'
+    '        }\n'
+    '    }\n'
+    '    while stmt_ref.stmt.execution_state().is_running() {\n'
+    '        let result = sqlite3_step(stmt);\n'
+    '        if result != SQLITE_DONE && result != SQLITE_ROW {\n'
+    '            return result;\n'
+    '        }\n'
+    '    }\n'
+    '    SQLITE_OK\n'
+    '}\n'
+)
+
+with open(PATH) as f:
+    s = f.read()
+if OLD_FINALIZE not in s:
+    sys.exit(f'{PATH}: sqlite3_finalize stmt_list block not found')
+s = s.replace(OLD_FINALIZE, NEW_FINALIZE, 1)
+if OLD_DRAIN not in s:
+    sys.exit(f'{PATH}: stmt_run_to_completion block not found')
+s = s.replace(OLD_DRAIN, NEW_DRAIN, 1)
+with open(PATH, 'w') as f:
+    f.write(s)
+print('patched sqlite3_finalize + stmt_run_to_completion for GC re-entry')

.github/turso-patches/06-max-custom-funcs-32-to-64.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""
+Bump MAX_CUSTOM_FUNCS from 32 to 64 (sqlite3/src/lib.rs).
+
+Turso's custom-function registry is capped at 32 pre-generated bridge
+trampolines; the driver registers 44 UDFs, so the last 12 silently fail.
+Bump to 64 by adding 32 more func_bridge!/FUNC_BRIDGES entries.
+"""
+
+import re
+import sys
+
+PATH = 'sqlite3/src/lib.rs'
+
+with open(PATH) as f:
+    s = f.read()
+
+OLD_MAX = 'const MAX_CUSTOM_FUNCS: usize = 32;'
+NEW_MAX = 'const MAX_CUSTOM_FUNCS: usize = 64;'
+if OLD_MAX not in s:
+    sys.exit(f'{PATH}: MAX_CUSTOM_FUNCS not found')
+s = s.replace(OLD_MAX, NEW_MAX, 1)
+
+# Inject 32 more func_bridge! declarations after func_bridge_31.
+bridge_marker = 'func_bridge!(31, func_bridge_31);\n'
+if bridge_marker not in s:
+    sys.exit(f'{PATH}: func_bridge_31 marker not found')
+extra_bridges = ''.join(
+    f'func_bridge!({i}, func_bridge_{i});\n' for i in range(32, 64)
+)
+s = s.replace(bridge_marker, bridge_marker + extra_bridges, 1)
+
+# Extend the FUNC_BRIDGES array: find the closing `];` of the static
+# and inject the extra entries before it.
+pat = re.compile(
+    r'(static FUNC_BRIDGES: \[ScalarFunction; MAX_CUSTOM_FUNCS\] = \[\n'
+    r'(?:\s*func_bridge_\d+,\n)+)(\];\n)'
+)
+m = pat.search(s)
+if m is None:
+    sys.exit(f'{PATH}: FUNC_BRIDGES array not found')
+extra_entries = ''.join(f'    func_bridge_{i},\n' for i in range(32, 64))
+s = s[:m.start(2)] + extra_entries + s[m.start(2):]
+
+with open(PATH, 'w') as f:
+    f.write(s)
+print('patched MAX_CUSTOM_FUNCS 32 -> 64')

.github/turso-patches/07-function-name-case-insensitive.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+Function-name lookup case-insensitivity (core/connection.rs + core/ext/mod.rs).
+
+SQLite looks up function names case-insensitively, but Turso's extension
+registry stores names as-is and connection.rs looks them up with
+HashMap::get directly. The driver's translator emits e.g. THROW(...)
+uppercase, so 32 tests fail with "no such function: THROW" even though
+we registered "throw". Normalise to lowercase at both register and
+lookup sites.
+"""
+
+import sys
+
+CONN = 'core/connection.rs'
+EXT = 'core/ext/mod.rs'
+
+with open(CONN) as f:
+    s = f.read()
+old = 'self.functions.get(name).cloned()'
+new = 'self.functions.get(&name.to_lowercase()).cloned()'
+if old not in s:
+    sys.exit(f'{CONN}: resolve_function lookup not found')
+with open(CONN, 'w') as f:
+    f.write(s.replace(old, new, 1))
+
+with open(EXT) as f:
+    s = f.read()
+old = '(*ext_ctx.syms).functions.insert(\n            name_str.clone(),'
+new = '(*ext_ctx.syms).functions.insert(\n            name_str.to_lowercase(),'
+if old not in s:
+    sys.exit(f'{EXT}: register_scalar_function insert not found')
+with open(EXT, 'w') as f:
+    f.write(s.replace(old, new, 1))
+
+print('patched function-name case (register + resolve)')