dirsql 0.3.21__tar.gz → 0.3.23__tar.gz

{dirsql-0.3.21 → dirsql-0.3.23}/Cargo.lock

@@ -499,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.21"
+version = "0.3.23"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.21 → dirsql-0.3.23}/Cargo.toml

@@ -1,5 +1,9 @@
 [workspace]
 members = ["packages/python", "packages/rust"]
+# Test-only loadable-extension fixture, built on demand by
+# packages/rust/tests/extensions.rs. Excluded so it isn't built/linted by
+# `cargo build --workspace` / `cargo clippy --workspace`.
+exclude = ["packages/rust/tests/fixtures/testext"]
 resolver = "2"
 
 [workspace.package]

{dirsql-0.3.21 → dirsql-0.3.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.21
+Version: 0.3.23
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.3.21 → dirsql-0.3.23}/dirsql/_async_test.py

@@ -1,10 +1,10 @@
 """Unit tests for the DirSQL async wrapper."""
 
-from __future__ import annotations
+from unittest.mock import patch
 
 import pytest
 
-from dirsql import _async as async_mod
+import dirsql._async as async_mod
 
 
 class _FakeRustDirSQL:
@@ -50,32 +50,32 @@ class _FakeWatcherDb:
 def describe_DirSQL_async():
     def describe_ready_and_query():
         @pytest.mark.asyncio
-        async def it_uses_the_background_db(monkeypatch):
-            monkeypatch.setattr(async_mod, "_RustDirSQL", _FakeRustDirSQL)
-
-            db = async_mod.DirSQL("/tmp/root", tables=["table-a"], ignore=["**/*.tmp"])
-            await db.ready()
+        async def it_uses_the_background_db():
+            with patch.object(async_mod, "_RustDirSQL", _FakeRustDirSQL):
+                db = async_mod.DirSQL(
+                    "/tmp/root", tables=["table-a"], ignore=["**/*.tmp"]
+                )
+                await db.ready()
 
-            results = await db.query("SELECT 1")
+                results = await db.query("SELECT 1")
 
-            assert db._db.root == "/tmp/root"
-            assert db._db.tables == ["table-a"]
-            assert db._db.ignore == ["**/*.tmp"]
-            assert db._db.query_calls == ["SELECT 1"]
-            assert results == [{"sql": "SELECT 1"}]
+                assert db._db.root == "/tmp/root"
+                assert db._db.tables == ["table-a"]
+                assert db._db.ignore == ["**/*.tmp"]
+                assert db._db.query_calls == ["SELECT 1"]
+                assert results == [{"sql": "SELECT 1"}]
 
         @pytest.mark.asyncio
-        async def it_propagates_initialization_errors(monkeypatch):
+        async def it_propagates_initialization_errors():
             class _BoomDirSQL:
                 def __init__(self, *args, **kwargs):
                     raise RuntimeError("boom")
 
-            monkeypatch.setattr(async_mod, "_RustDirSQL", _BoomDirSQL)
+            with patch.object(async_mod, "_RustDirSQL", _BoomDirSQL):
+                db = async_mod.DirSQL("/tmp/root", tables=["table-a"])
 
-            db = async_mod.DirSQL("/tmp/root", tables=["table-a"])
-
-            with pytest.raises(RuntimeError, match="boom"):
-                await db.ready()
+                with pytest.raises(RuntimeError, match="boom"):
+                    await db.ready()
 
     def describe_watch_stream():
         @pytest.mark.asyncio

{dirsql-0.3.21 → dirsql-0.3.23}/dirsql/cli/binary_path_test.py

@@ -5,7 +5,7 @@ from unittest.mock import patch
 
 import pytest
 
-from dirsql.cli import binary_path as bp_module
+import dirsql.cli.binary_path as bp_module
 from dirsql.cli.binary_path import binary_path
 
 

{dirsql-0.3.21 → dirsql-0.3.23}/dirsql/cli/main_test.py

@@ -2,7 +2,6 @@
 
 import io
 import os
-import subprocess
 import sys
 from unittest.mock import patch
 
@@ -35,7 +34,9 @@ def describe_main():
             with (
                 patch.object(main_module, "binary_path", return_value="C:/dirsql.exe"),
                 patch.object(main_module, "is_windows", return_value=True),
-                patch.object(subprocess, "run", return_value=_Completed(7)) as run,
+                patch(
+                    "dirsql.cli.main.subprocess.run", return_value=_Completed(7)
+                ) as run,
             ):
                 assert main(["--version"]) == 7
             run.assert_called_once_with(["C:/dirsql.exe", "--version"])
@@ -44,7 +45,7 @@ def describe_main():
             with (
                 patch.object(main_module, "binary_path", return_value="C:/dirsql.exe"),
                 patch.object(main_module, "is_windows", return_value=True),
-                patch.object(subprocess, "run", return_value=_Completed(0)),
+                patch("dirsql.cli.main.subprocess.run", return_value=_Completed(0)),
                 patch.object(os, "execv") as execv,
             ):
                 main([])
@@ -81,7 +82,9 @@ def describe_main():
                 patch.object(sys, "argv", ["dirsql", "--help"]),
                 patch.object(main_module, "binary_path", return_value="C:/dirsql.exe"),
                 patch.object(main_module, "is_windows", return_value=True),
-                patch.object(subprocess, "run", return_value=_Completed(0)) as run,
+                patch(
+                    "dirsql.cli.main.subprocess.run", return_value=_Completed(0)
+                ) as run,
             ):
                 main(argv=None)
             run.assert_called_once_with(["C:/dirsql.exe", "--help"])
@@ -93,12 +96,10 @@ def describe_main():
 
         def it_dispatches_to_interpret_run_and_returns_its_exit_code():
             # main.py does `from .interpret.run import run` lazily, so
-            # patching the `run` function on the submodule is sufficient
-            # -- each call resolves the name freshly from the submodule.
-            from .interpret import run as run_submod
-
+            # patching the `run` function on its module by its dotted path
+            # is sufficient -- each call resolves the name freshly.
             with (
-                patch.object(run_submod, "run", return_value=0) as interpret_run,
+                patch("dirsql.cli.interpret.run.run", return_value=0) as interpret_run,
                 patch.object(main_module, "binary_path") as binary_path,
             ):
                 assert main(["interpret", "config.py"]) == 0
@@ -106,15 +107,11 @@ def describe_main():
             binary_path.assert_not_called()
 
         def it_propagates_a_nonzero_interpret_exit():
-            from .interpret import run as run_submod
-
-            with patch.object(run_submod, "run", return_value=2):
+            with patch("dirsql.cli.interpret.run.run", return_value=2):
                 assert main(["interpret", "bad.py"]) == 2
 
         def it_returns_130_on_keyboard_interrupt():
-            from .interpret import run as run_submod
-
-            with patch.object(run_submod, "run", side_effect=KeyboardInterrupt()):
+            with patch("dirsql.cli.interpret.run.run", side_effect=KeyboardInterrupt()):
                 assert main(["interpret", "config.py"]) == 130
 
         def it_does_not_intercept_when_interpret_is_not_argv_0():
@@ -123,7 +120,7 @@ def describe_main():
             with (
                 patch.object(main_module, "binary_path", return_value="/bin/dirsql"),
                 patch.object(main_module, "is_windows", return_value=True),
-                patch.object(subprocess, "run", return_value=_Completed(0)),
+                patch("dirsql.cli.main.subprocess.run", return_value=_Completed(0)),
             ):
                 main(["--verbose", "interpret", "config.py"])
             # binary_path was reached, meaning we did NOT take the

{dirsql-0.3.21 → dirsql-0.3.23}/docs/cli/config.md

@@ -138,6 +138,33 @@ persist = true
 See [Persistence](../guide/persistence.md) for the full reconcile algorithm,
 storage layout, and limitations.
 
+## Loading extensions
+
+You can load SQLite extensions by specifying them in a config.
+
+Declare each extension as a `[[dirsql.extension]]` entry:
+
+```toml
+[[dirsql.extension]]
+path       = "./ext/myext.dylib"
+entrypoint = "sqlite3_myext_init"
+```
+
+- **`path`** — a path to the extension's shared library (`.so` / `.dylib` /
+  `.dll`). Relative paths resolve against the config file's parent directory.
+- **`entrypoint`** *(optional)* — the extension's init symbol. When omitted,
+  SQLite derives a default from the filename; set it when that default does not
+  match (for example, `sqlite-vec`'s entry point is `sqlite3_vec_init`).
+
+**Note**: `dirsql` enables extension loading only while loading the configured libraries,
+then disables it again, so `load_extension()` is not exposed via SQL to the user.
+
+Extensions add **functions** you can call in queries and in a regular table's
+DDL (defaults, generated columns). An extension-backed **virtual table** cannot
+be declared as a `[[table]]` — `dirsql` tables are per-file row tables — so a
+`CREATE VIRTUAL TABLE` DDL is rejected; call the extension's functions in your
+queries instead.
+
 ## Strict Mode
 
 By default, auto-injected virtuals that aren't in the DDL are silently

{dirsql-0.3.21 → dirsql-0.3.23}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.21"
+version = "0.3.23"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.21/packages/rust → dirsql-0.3.23/packages/python}/docs/cli/config.md

@@ -138,6 +138,33 @@ persist = true
 See [Persistence](../guide/persistence.md) for the full reconcile algorithm,
 storage layout, and limitations.
 
+## Loading extensions
+
+You can load SQLite extensions by specifying them in a config.
+
+Declare each extension as a `[[dirsql.extension]]` entry:
+
+```toml
+[[dirsql.extension]]
+path       = "./ext/myext.dylib"
+entrypoint = "sqlite3_myext_init"
+```
+
+- **`path`** — a path to the extension's shared library (`.so` / `.dylib` /
+  `.dll`). Relative paths resolve against the config file's parent directory.
+- **`entrypoint`** *(optional)* — the extension's init symbol. When omitted,
+  SQLite derives a default from the filename; set it when that default does not
+  match (for example, `sqlite-vec`'s entry point is `sqlite3_vec_init`).
+
+**Note**: `dirsql` enables extension loading only while loading the configured libraries,
+then disables it again, so `load_extension()` is not exposed via SQL to the user.
+
+Extensions add **functions** you can call in queries and in a regular table's
+DDL (defaults, generated columns). An extension-backed **virtual table** cannot
+be declared as a `[[table]]` — `dirsql` tables are per-file row tables — so a
+`CREATE VIRTUAL TABLE` DDL is rejected; call the extension's functions in your
+queries instead.
+
 ## Strict Mode
 
 By default, auto-injected virtuals that aren't in the DDL are silently

{dirsql-0.3.21 → dirsql-0.3.23}/packages/rust/Cargo.toml

@@ -53,7 +53,7 @@ futures-channel.workspace = true
 globset = "0.4"
 notify = "7"
 regex.workspace = true
-rusqlite = { version = "0.34", features = ["bundled"] }
+rusqlite = { version = "0.34", features = ["bundled", "load_extension"] }
 serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true

{dirsql-0.3.21/packages/python → dirsql-0.3.23/packages/rust}/docs/cli/config.md

@@ -138,6 +138,33 @@ persist = true
 See [Persistence](../guide/persistence.md) for the full reconcile algorithm,
 storage layout, and limitations.
 
+## Loading extensions
+
+You can load SQLite extensions by specifying them in a config.
+
+Declare each extension as a `[[dirsql.extension]]` entry:
+
+```toml
+[[dirsql.extension]]
+path       = "./ext/myext.dylib"
+entrypoint = "sqlite3_myext_init"
+```
+
+- **`path`** — a path to the extension's shared library (`.so` / `.dylib` /
+  `.dll`). Relative paths resolve against the config file's parent directory.
+- **`entrypoint`** *(optional)* — the extension's init symbol. When omitted,
+  SQLite derives a default from the filename; set it when that default does not
+  match (for example, `sqlite-vec`'s entry point is `sqlite3_vec_init`).
+
+**Note**: `dirsql` enables extension loading only while loading the configured libraries,
+then disables it again, so `load_extension()` is not exposed via SQL to the user.
+
+Extensions add **functions** you can call in queries and in a regular table's
+DDL (defaults, generated columns). An extension-backed **virtual table** cannot
+be declared as a `[[table]]` — `dirsql` tables are per-file row tables — so a
+`CREATE VIRTUAL TABLE` DDL is rejected; call the extension's functions in your
+queries instead.
+
 ## Strict Mode
 
 By default, auto-injected virtuals that aren't in the DDL are silently

{dirsql-0.3.21 → dirsql-0.3.23}/packages/rust/src/config.rs

@@ -13,6 +13,9 @@ pub enum ConfigError {
 
     #[error("Missing required field '{0}' in [[table]] entry")]
     MissingField(&'static str),
+
+    #[error("Missing required field '{0}' in [[dirsql.extension]] entry")]
+    MissingExtensionField(&'static str),
 }
 
 pub type Result<T> = std::result::Result<T, ConfigError>;
@@ -33,6 +36,29 @@ pub struct Config {
     /// Optional override for the on-disk cache location. Resolved relative
     /// to the config file's parent directory when relative.
     pub persist_path: Option<PathBuf>,
+    /// SQLite extensions to load at startup, declared via
+    /// `[[dirsql.extension]]`. Paths are taken verbatim from the file here;
+    /// relative paths are resolved against the config file's parent directory
+    /// by the caller (`DirSQLBuilder::resolve`).
+    pub extensions: Vec<ExtensionSpec>,
+}
+
+/// A SQLite extension to load at startup.
+///
+/// Declared as a `[[dirsql.extension]]` array entry. dirsql loads each
+/// extension onto the connection before any `CREATE TABLE` runs, then
+/// disables loading again so the SQL `load_extension()` function is never
+/// left exposed.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+pub struct ExtensionSpec {
+    /// Local path to the extension's shared library (`.so` / `.dylib` /
+    /// `.dll`). Relative paths resolve against the config file's parent
+    /// directory.
+    pub path: PathBuf,
+    /// Optional init-symbol override. When `None`, SQLite derives the entry
+    /// point from the filename, which often does not match — set this when
+    /// the extension's init function isn't `sqlite3_<filename>_init`.
+    pub entrypoint: Option<String>,
 }
 
 /// Configuration for a single table.
@@ -65,6 +91,13 @@ struct RawDirsql {
     ignore: Option<Vec<String>>,
     persist: Option<bool>,
     persist_path: Option<PathBuf>,
+    extension: Option<Vec<RawExtension>>,
+}
+
+#[derive(Deserialize)]
+struct RawExtension {
+    path: Option<String>,
+    entrypoint: Option<String>,
 }
 
 #[derive(Deserialize)]
@@ -84,16 +117,31 @@ pub fn load_config(path: &Path) -> Result<Config> {
 pub fn load_config_str(content: &str) -> Result<Config> {
     let raw: RawConfig = toml::from_str(content)?;
 
-    let (root, ignore, persist, persist_path) = match raw.dirsql {
+    let (root, ignore, persist, persist_path, raw_extensions) = match raw.dirsql {
         Some(d) => (
             d.root,
             d.ignore.unwrap_or_default(),
             d.persist.unwrap_or(false),
             d.persist_path,
+            d.extension.unwrap_or_default(),
         ),
-        None => (None, Vec::new(), false, None),
+        None => (None, Vec::new(), false, None, Vec::new()),
     };
 
+    let mut extensions = Vec::with_capacity(raw_extensions.len());
+    for raw_ext in raw_extensions {
+        // An empty `path = ""` is as unusable as a missing key: reject it at
+        // parse time rather than silently resolving it to a directory later.
+        let path = raw_ext
+            .path
+            .filter(|p| !p.is_empty())
+            .ok_or(ConfigError::MissingExtensionField("path"))?;
+        extensions.push(ExtensionSpec {
+            path: PathBuf::from(path),
+            entrypoint: raw_ext.entrypoint,
+        });
+    }
+
     let raw_tables = raw.table.unwrap_or_default();
     let mut tables = Vec::with_capacity(raw_tables.len());
 
@@ -114,6 +162,7 @@ pub fn load_config_str(content: &str) -> Result<Config> {
         tables,
         persist,
         persist_path,
+        extensions,
     })
 }
 
@@ -341,4 +390,90 @@ format = "json"
         let config = load_config_str(toml).unwrap();
         assert_eq!(config.tables.len(), 1);
     }
+
+    #[test]
+    fn extensions_parse_path_and_entrypoint() {
+        let toml = r#"
+[[dirsql.extension]]
+path = "./ext/vec0.dylib"
+entrypoint = "sqlite3_vec_init"
+
+[[table]]
+ddl = "CREATE TABLE t (_path TEXT)"
+glob = "*.json"
+"#;
+        let config = load_config_str(toml).unwrap();
+        assert_eq!(config.extensions.len(), 1);
+        assert_eq!(config.extensions[0].path, PathBuf::from("./ext/vec0.dylib"));
+        assert_eq!(
+            config.extensions[0].entrypoint.as_deref(),
+            Some("sqlite3_vec_init")
+        );
+    }
+
+    #[test]
+    fn extension_entrypoint_is_optional() {
+        let toml = r#"
+[[dirsql.extension]]
+path = "ext.so"
+"#;
+        let config = load_config_str(toml).unwrap();
+        assert_eq!(config.extensions.len(), 1);
+        assert!(config.extensions[0].entrypoint.is_none());
+    }
+
+    #[test]
+    fn extension_missing_path_errors() {
+        let toml = r#"
+[[dirsql.extension]]
+entrypoint = "sqlite3_x_init"
+"#;
+        let err = load_config_str(toml).unwrap_err();
+        assert!(
+            matches!(err, ConfigError::MissingExtensionField("path")),
+            "got: {err:?}"
+        );
+    }
+
+    #[test]
+    fn extensions_default_empty_when_absent() {
+        let toml = r#"
+[[table]]
+ddl = "CREATE TABLE t (_path TEXT)"
+glob = "*.json"
+"#;
+        let config = load_config_str(toml).unwrap();
+        assert!(config.extensions.is_empty());
+    }
+
+    #[test]
+    fn multiple_extensions_preserve_order() {
+        let toml = r#"
+[[dirsql.extension]]
+path = "a.so"
+
+[[dirsql.extension]]
+path = "b.so"
+"#;
+        let config = load_config_str(toml).unwrap();
+        assert_eq!(config.extensions.len(), 2);
+        assert_eq!(config.extensions[0].path, PathBuf::from("a.so"));
+        assert_eq!(config.extensions[1].path, PathBuf::from("b.so"));
+    }
+
+    #[test]
+    fn extension_empty_path_errors() {
+        // An empty `path = ""` is as unusable as a missing key — it must be
+        // rejected at parse time, not silently accepted and later resolved to
+        // the config's parent directory. (RED for #225 review finding #4.)
+        let toml = r#"
+[[dirsql.extension]]
+path = ""
+"#;
+        let err = load_config_str(toml).unwrap_err();
+        assert!(
+            matches!(err, ConfigError::MissingExtensionField("path")),
+            "got: {err:?}"
+        );
+    }
 }

{dirsql-0.3.21 → dirsql-0.3.23}/packages/rust/src/db.rs

@@ -75,6 +75,27 @@ impl Db {
         &self.conn
     }
 
+    /// Load a SQLite extension shared library onto this connection.
+    ///
+    /// `entrypoint` overrides the init symbol; when `None`, SQLite derives it
+    /// from the filename. Extension loading is enabled for the duration of the
+    /// call via [`rusqlite::LoadExtensionGuard`] and disabled again on return,
+    /// so the SQL `load_extension()` function is never left exposed to later
+    /// queries. A missing or unloadable file surfaces as [`DbError::Sqlite`].
+    pub fn load_extension(&self, path: &Path, entrypoint: Option<&str>) -> Result<()> {
+        // SAFETY: loading an extension executes native code from `path`. The
+        // path is operator-supplied configuration (a `[[dirsql.extension]]`
+        // entry), at the same trust level as the DDL the operator already
+        // controls. The guard enables loading on construction and disables it
+        // on drop at the end of this block — after the load — so the SQL
+        // `load_extension()` function is never left exposed to later queries.
+        unsafe {
+            let _guard = rusqlite::LoadExtensionGuard::new(&self.conn)?;
+            self.conn.load_extension(path, entrypoint)?;
+        }
+        Ok(())
+    }
+
     /// Create a table from a user-provided DDL statement.
     /// Automatically injects internal tracking columns (_dirsql_file_path, _dirsql_row_index).
     ///
@@ -83,6 +104,20 @@ impl Db {
     /// `CREATE TABLE foo;DROP_TABLE_bar--(id TEXT)` would parse to a poisoned
     /// internal table name and break downstream `format!()`-built SQL.
     pub fn create_table(&self, ddl: &str) -> Result<()> {
+        // A dirsql table is a per-file row table: create_table injects
+        // `_dirsql_` tracking columns and the engine inserts one row per file.
+        // That is structurally incompatible with an extension-backed virtual
+        // table, so reject `CREATE VIRTUAL TABLE` with a clear message instead
+        // of mangling the DDL via column injection. Load the extension and use
+        // its functions in queries instead.
+        if is_virtual_table_ddl(ddl) {
+            return Err(DbError::DdlParse(
+                "CREATE VIRTUAL TABLE is not supported as a dirsql table \
+                 (dirsql tables are per-file row tables); load the extension \
+                 and call its functions in queries instead"
+                    .to_string(),
+            ));
+        }
         let table = parse_table_name(ddl).ok_or_else(|| DbError::DdlParse(ddl.to_string()))?;
         validate_identifier(&table)?;
         let augmented = inject_tracking_columns(ddl)?;
@@ -390,6 +425,16 @@ pub fn parse_table_name(ddl: &str) -> Option<String> {
     if name.is_empty() { None } else { Some(name) }
 }
 
+/// True if `ddl` is a `CREATE VIRTUAL TABLE` statement. dirsql tables are
+/// per-file row tables (create_table injects `_dirsql_` tracking columns and
+/// inserts one row per file), which is structurally incompatible with an
+/// extension-backed virtual table — those are rejected with a clear error
+/// rather than mangled by column injection.
+fn is_virtual_table_ddl(ddl: &str) -> bool {
+    let normalized = ddl.split_whitespace().collect::<Vec<_>>().join(" ");
+    normalized.to_uppercase().contains("CREATE VIRTUAL TABLE")
+}
+
 impl From<rusqlite::types::Value> for Value {
     fn from(v: rusqlite::types::Value) -> Self {
         match v {
@@ -1078,4 +1123,55 @@ mod tests {
         assert_eq!(rows.len(), 1);
         assert!(!rows[0].contains_key("_dirsql_file_path"));
     }
+
+    // --- load_extension: error path (missing shared library) ---
+
+    #[test]
+    fn load_extension_missing_file_errors() {
+        // Loading is enabled for the call (the guard succeeds), the load of a
+        // nonexistent shared library fails, and the error propagates as
+        // DbError::Sqlite. Exercises the enable→load path; the success arm is
+        // covered by the integration suite against a real extension.
+        let db = Db::new().unwrap();
+        let err = db
+            .load_extension(Path::new("/nonexistent/dirsql-no-such-ext.so"), None)
+            .unwrap_err();
+        assert!(matches!(err, DbError::Sqlite(_)), "got: {err}");
+    }
+
+    // --- create_table: virtual tables are not supported as dirsql tables ---
+
+    #[test]
+    fn create_table_rejects_virtual_table_with_clear_error() {
+        // A dirsql table is a per-file row table: create_table injects
+        // _dirsql_ tracking columns and the engine inserts one row per file.
+        // That is structurally incompatible with an extension-backed virtual
+        // table, so a `CREATE VIRTUAL TABLE` DDL must fail with a clear,
+        // specific error rather than a confusing "no such module" / mangled
+        // DDL. (RED for #225 review finding #1.)
+        let db = Db::new().unwrap();
+        let err = db
+            .create_table("CREATE VIRTUAL TABLE vss USING vec0(embedding float[4])")
+            .unwrap_err();
+        // Must be a clear "not supported" message, NOT the generic
+        // `DdlParse` echo (which trivially contains "virtual table" because it
+        // echoes the DDL back).
+        let msg = err.to_string().to_lowercase();
+        assert!(
+            msg.contains("virtual table") && msg.contains("not supported"),
+            "expected a clear 'virtual table not supported' error, not a generic DDL-parse echo, got: {err}"
+        );
+    }
+
+    #[test]
+    fn is_virtual_table_ddl_detects_variants() {
+        assert!(is_virtual_table_ddl("CREATE VIRTUAL TABLE x USING vec0(a)"));
+        assert!(is_virtual_table_ddl(
+            "create   virtual   table x using fts5(a)"
+        ));
+        assert!(!is_virtual_table_ddl("CREATE TABLE x (a TEXT)"));
+        assert!(!is_virtual_table_ddl(
+            "CREATE TABLE IF NOT EXISTS x (a TEXT)"
+        ));
+    }
 }