dirsql 0.3.37__tar.gz → 0.3.38__tar.gz

{dirsql-0.3.37 → dirsql-0.3.38}/Cargo.lock

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

{dirsql-0.3.37 → dirsql-0.3.38}/PKG-INFO

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

{dirsql-0.3.37/packages/rust → dirsql-0.3.38}/docs/guide/tables.md

@@ -72,7 +72,7 @@ ddl="CREATE TABLE metrics (name TEXT, value REAL, count INTEGER)"
 ddl="CREATE TABLE items (id TEXT PRIMARY KEY, name TEXT NOT NULL)"
 ```
 
-The table name is parsed from the DDL. It must be a valid SQLite identifier.
+The table name is parsed from the DDL and must resolve to a valid SQLite identifier.
 
 ### `glob`
 

{dirsql-0.3.37 → dirsql-0.3.38}/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.37"
+version = "0.3.38"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.37 → dirsql-0.3.38/packages/python}/docs/guide/tables.md

@@ -72,7 +72,7 @@ ddl="CREATE TABLE metrics (name TEXT, value REAL, count INTEGER)"
 ddl="CREATE TABLE items (id TEXT PRIMARY KEY, name TEXT NOT NULL)"
 ```
 
-The table name is parsed from the DDL. It must be a valid SQLite identifier.
+The table name is parsed from the DDL and must resolve to a valid SQLite identifier.
 
 ### `glob`
 

dirsql-0.3.38/packages/python/e2e-attestation.json

@@ -0,0 +1,6 @@
+{
+  "command": "uv run python -m pytest tests/e2e -q",
+  "ran_at": 1782733085,
+  "exit_code": 0,
+  "commit": "99b20d078e4bb7a82fcbff6a3f08c5f3fe95f234"
+}

{dirsql-0.3.37/packages/python → dirsql-0.3.38/packages/rust}/docs/guide/tables.md

@@ -72,7 +72,7 @@ ddl="CREATE TABLE metrics (name TEXT, value REAL, count INTEGER)"
 ddl="CREATE TABLE items (id TEXT PRIMARY KEY, name TEXT NOT NULL)"
 ```
 
-The table name is parsed from the DDL. It must be a valid SQLite identifier.
+The table name is parsed from the DDL and must resolve to a valid SQLite identifier.
 
 ### `glob`
 

{dirsql-0.3.37 → dirsql-0.3.38}/packages/rust/src/db.rs

@@ -402,27 +402,89 @@ impl rusqlite::types::ToSql for Value {
     }
 }
 
-/// Extract the table name from a CREATE TABLE DDL statement.
-/// Handles: CREATE TABLE name (...), CREATE TABLE IF NOT EXISTS name (...)
+/// Extract the table name from a `CREATE TABLE` DDL statement.
+///
+/// The name token in `CREATE TABLE [IF NOT EXISTS] <name> (...)` may be:
+///   - a bare identifier:    `comments`
+///   - a quoted identifier:  `"comments"`, `` `comments` ``, `[comments]`
+///   - schema-qualified:     `main.comments`, `"main"."comments"`
+///
+/// Surrounding quotes are SQL *delimiters*, not part of the name, so they are
+/// stripped: a tool that emits `CREATE TABLE "comments" (...)` (as ORMs and
+/// schema generators routinely do) names the table `comments`. Schema-qualified
+/// names resolve to the table segment. Returns `None` when the input isn't a
+/// `CREATE TABLE` or carries no name token.
+///
+/// This is deliberately a small, pure tokenizer rather than a full SQL parser
+/// (or a round-trip through SQLite): dirsql constrains table names to safe
+/// unquoted identifiers via [`validate_identifier`], so the handful of forms
+/// above are the only ones that can actually resolve to a usable table.
 pub fn parse_table_name(ddl: &str) -> Option<String> {
     let upper = ddl.to_uppercase();
     let idx = upper.find("CREATE TABLE")?;
-    let rest = &ddl[idx + "CREATE TABLE".len()..].trim_start();
+    let mut rest = ddl[idx + "CREATE TABLE".len()..].trim_start();
 
-    // Skip optional "IF NOT EXISTS"
-    let rest = if rest.to_uppercase().starts_with("IF NOT EXISTS") {
-        rest["IF NOT EXISTS".len()..].trim_start()
-    } else {
-        rest
-    };
+    // Skip optional "IF NOT EXISTS". `.get()` avoids slicing on a non-char
+    // boundary when the name itself begins with a multi-byte character.
+    const IF_NOT_EXISTS: &str = "IF NOT EXISTS";
+    if rest
+        .get(..IF_NOT_EXISTS.len())
+        .is_some_and(|p| p.eq_ignore_ascii_case(IF_NOT_EXISTS))
+    {
+        rest = rest[IF_NOT_EXISTS.len()..].trim_start();
+    }
 
-    // Table name is everything up to the first whitespace or '('
-    let name: String = rest
-        .chars()
-        .take_while(|c| !c.is_whitespace() && *c != '(')
-        .collect();
+    // Parse dot-separated identifier segments (`schema.table`) and keep the
+    // last one: the table name. Each segment may be quoted independently.
+    let mut chars = rest.chars().peekable();
+    let mut table = parse_identifier(&mut chars)?;
+    while chars.peek() == Some(&'.') {
+        chars.next();
+        table = parse_identifier(&mut chars)?;
+    }
+
+    if table.is_empty() { None } else { Some(table) }
+}
 
-    if name.is_empty() { None } else { Some(name) }
+/// Read one identifier segment from `chars`: a quoted identifier
+/// (`"..."`, `` `...` ``, or `[...]`, with the doubled-delimiter escape for the
+/// matching close on the SQL-standard quote forms) or a bare run up to the
+/// first whitespace, `(`, or `.`. Returns the *unquoted* text. Returns `None`
+/// only when the cursor is already exhausted.
+fn parse_identifier(chars: &mut std::iter::Peekable<std::str::Chars<'_>>) -> Option<String> {
+    let (open, close) = match *chars.peek()? {
+        '"' => ('"', '"'),
+        '`' => ('`', '`'),
+        '[' => ('[', ']'),
+        _ => {
+            let mut bare = String::new();
+            while let Some(&c) = chars.peek() {
+                if c.is_whitespace() || c == '(' || c == '.' {
+                    break;
+                }
+                bare.push(c);
+                chars.next();
+            }
+            return Some(bare);
+        }
+    };
+
+    chars.next(); // consume the opening delimiter
+    let mut name = String::new();
+    while let Some(c) = chars.next() {
+        if c == close {
+            // On `"` / `` ` ``, a doubled close delimiter is an escaped literal
+            // (`""` -> `"`); SQLite's `[...]` form has no such escape.
+            if open != '[' && chars.peek() == Some(&close) {
+                chars.next();
+                name.push(close);
+                continue;
+            }
+            break;
+        }
+        name.push(c);
+    }
+    Some(name)
 }
 
 /// True if `ddl` is a `CREATE VIRTUAL TABLE` statement. dirsql tables are
@@ -630,6 +692,93 @@ mod tests {
         assert_eq!(parse_table_name("CREATE TABLE "), None);
     }
 
+    #[test]
+    fn parse_table_name_double_quoted() {
+        // The canonical ORM / schema-generator shape: the quotes are SQL
+        // delimiters and must be stripped to the bare `comments`.
+        assert_eq!(
+            parse_table_name(r#"CREATE TABLE "comments" (id TEXT)"#),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_double_quoted_no_space_before_paren() {
+        assert_eq!(
+            parse_table_name(r#"CREATE TABLE "comments"(id TEXT)"#),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_backtick_quoted() {
+        assert_eq!(
+            parse_table_name("CREATE TABLE `comments` (id TEXT)"),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_bracket_quoted() {
+        // SQLite's `[ident]` form ends at the first `]` -- no doubling escape.
+        assert_eq!(
+            parse_table_name("CREATE TABLE [comments] (id TEXT)"),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_double_quote_escape() {
+        // `""` inside a double-quoted identifier is one literal `"`. The
+        // extracted name is later rejected by `validate_identifier`; here we
+        // only assert the tokenizer unescapes correctly.
+        assert_eq!(
+            parse_table_name(r#"CREATE TABLE "we""ird" (id TEXT)"#),
+            Some("we\"ird".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_if_not_exists_quoted_mixed_case() {
+        assert_eq!(
+            parse_table_name(r#"CREATE TABLE if not exists "comments" (id TEXT)"#),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_schema_qualified() {
+        // `schema.table` resolves to the table segment (the name SQLite stores
+        // in `sqlite_master`).
+        assert_eq!(
+            parse_table_name("CREATE TABLE main.comments (id TEXT)"),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_schema_qualified_quoted() {
+        assert_eq!(
+            parse_table_name(r#"CREATE TABLE "main"."comments" (id TEXT)"#),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_runs_to_end_of_input() {
+        // Bare identifier terminated by EOF rather than whitespace/paren.
+        assert_eq!(
+            parse_table_name("CREATE TABLE comments"),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_missing_name_is_none() {
+        // A `(` where the name should be yields an empty token -> None.
+        assert_eq!(parse_table_name("CREATE TABLE (id TEXT)"), None);
+    }
+
     #[test]
     fn get_table_columns_returns_user_columns_only() {
         let db = Db::new().unwrap();

dirsql-0.3.37/packages/python/e2e-attestation.json

@@ -1,6 +0,0 @@
-{
-  "command": "uv run python -m pytest tests/e2e -q",
-  "ran_at": 1782732207,
-  "exit_code": 0,
-  "commit": "6a2dcb8948ae61431b6357df46ce00e8848173ac"
-}