sqlty 0.1.0__tar.gz → 0.2.0__tar.gz

{sqlty-0.1.0 → sqlty-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlty
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -111,13 +111,14 @@ CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT);
 ```python
 from sqlty import SQL
 
-# error: [stale-type] "SQL[tuple[int, str]] should be SQL[tuple[int, str | None]]"
+# error: [narrow-type] "SQL[tuple[int, str]] should be SQL[tuple[int, str | None]]"
 query = SQL[tuple[int, str]]("--sql\nSELECT id, email FROM users")
 ```
 
 `sqlty check --fix .` updates the type, and your type checker finds every
-caller that now needs a `None` check. `stale-type` is a warning by default; set
-`stale-type = "error"` under `[tool.sqlty.rules]` to fail CI on it
+caller that now needs a `None` check. `narrow-type` is an error, so CI fails on
+it; an annotation that is only wider than the rows, such as `str | None` for a
+column made `NOT NULL`, is a `stale-type` warning
 ([CI](https://jirikuncar.github.io/sqlty/recipes/ci/)). For rolling deploys,
 `sqlty breaking --against origin/main` exits 1 when old code breaks on the new
 schema or new code on the old one
@@ -174,8 +175,9 @@ conn.execute("--sql\nSELECT emial FROM users")
 asyncpg calls ([Parameters](https://jirikuncar.github.io/sqlty/guide/parameters/)).
 These are the mistakes coding agents make: every problem is one
 `file:line: [rule] message` line and a non-zero exit code they can act on, and
-the [sqlty skill](https://jirikuncar.github.io/sqlty/recipes/agents/) teaches
-them the conventions.
+the [sqlty skills](https://jirikuncar.github.io/sqlty/recipes/agents/) teach
+them the conventions. In Claude Code, `/plugin install sqlty --marketplace jirikuncar/sqlty`
+installs them.
 
 ## Get started
 

{sqlty-0.1.0 → sqlty-0.2.0}/README.md

@@ -78,13 +78,14 @@ CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT);
 ```python
 from sqlty import SQL
 
-# error: [stale-type] "SQL[tuple[int, str]] should be SQL[tuple[int, str | None]]"
+# error: [narrow-type] "SQL[tuple[int, str]] should be SQL[tuple[int, str | None]]"
 query = SQL[tuple[int, str]]("--sql\nSELECT id, email FROM users")
 ```
 
 `sqlty check --fix .` updates the type, and your type checker finds every
-caller that now needs a `None` check. `stale-type` is a warning by default; set
-`stale-type = "error"` under `[tool.sqlty.rules]` to fail CI on it
+caller that now needs a `None` check. `narrow-type` is an error, so CI fails on
+it; an annotation that is only wider than the rows, such as `str | None` for a
+column made `NOT NULL`, is a `stale-type` warning
 ([CI](https://jirikuncar.github.io/sqlty/recipes/ci/)). For rolling deploys,
 `sqlty breaking --against origin/main` exits 1 when old code breaks on the new
 schema or new code on the old one
@@ -141,8 +142,9 @@ conn.execute("--sql\nSELECT emial FROM users")
 asyncpg calls ([Parameters](https://jirikuncar.github.io/sqlty/guide/parameters/)).
 These are the mistakes coding agents make: every problem is one
 `file:line: [rule] message` line and a non-zero exit code they can act on, and
-the [sqlty skill](https://jirikuncar.github.io/sqlty/recipes/agents/) teaches
-them the conventions.
+the [sqlty skills](https://jirikuncar.github.io/sqlty/recipes/agents/) teach
+them the conventions. In Claude Code, `/plugin install sqlty --marketplace jirikuncar/sqlty`
+installs them.
 
 ## Get started
 

{sqlty-0.1.0 → sqlty-0.2.0}/pyproject.toml

@@ -61,7 +61,8 @@ manifest-path = "rust/crates/sqlty-ext/Cargo.toml"
 # registers the lazy "sqlty" codec lookup (see docs/guide/magic-codec.md).
 # The path is relative to the project root (maturin >= 1.12.1): the wheel gets
 # it at the root (python-source prefix stripped), the sdist at src/.
-include = ["src/sqlty_magic.pth"]
+# The Agent Skills are compiled into the extension, so only the sdist needs them.
+include = ["src/sqlty_magic.pth", { path = "skills/**/*", format = "sdist" }]
 
 [dependency-groups]
 dev = [

{sqlty-0.1.0 → sqlty-0.2.0}/rust/Cargo.lock

@@ -614,7 +614,7 @@ dependencies = [
 
 [[package]]
 name = "sqlty-bench"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "criterion",
  "sqlty-python",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "sqlty-core"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "pyo3",
  "sqlty-python",
@@ -633,7 +633,7 @@ dependencies = [
 
 [[package]]
 name = "sqlty-python"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "regex",
  "sqlty-sql",
@@ -642,7 +642,7 @@ dependencies = [
 
 [[package]]
 name = "sqlty-sql"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "insta",
  "regex",

{sqlty-0.1.0 → sqlty-0.2.0}/rust/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 description = "Rust engine of sqlty: SQL type inference and Python source rewriting"
 license = "MIT"

sqlty-0.2.0/rust/crates/sqlty-ext/build.rs

@@ -0,0 +1,51 @@
+//! Embeds the Agent Skills of `skills/` at the repository root, so `sqlty skill` prints the
+//! ones of its own version wherever the wheel is installed.
+
+use std::fmt::Write as _;
+use std::path::{Path, PathBuf};
+use std::{env, fs};
+
+fn main() {
+    let root = Path::new(&env::var("CARGO_MANIFEST_DIR").unwrap()).join("../../../skills");
+    let root = root
+        .canonicalize()
+        .unwrap_or_else(|e| panic!("{}: {e}", root.display()));
+    let mut files = Vec::new();
+    collect(&root, &mut files);
+    files.sort();
+    let mut out = String::from("pub(crate) static SKILLS: &[(&str, &str)] = &[\n");
+    for file in &files {
+        let relative = file
+            .strip_prefix(&root)
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .replace('\\', "/");
+        writeln!(
+            out,
+            "    ({relative:?}, include_str!({:?})),",
+            file.to_str().unwrap()
+        )
+        .unwrap();
+    }
+    out.push_str("];\n");
+    fs::write(
+        Path::new(&env::var("OUT_DIR").unwrap()).join("skills.rs"),
+        out,
+    )
+    .unwrap();
+}
+
+/// Every file under `dir`, and every directory for Cargo to watch.
+fn collect(dir: &Path, files: &mut Vec<PathBuf>) {
+    println!("cargo:rerun-if-changed={}", dir.display());
+    for entry in fs::read_dir(dir).unwrap() {
+        let path = entry.unwrap().path();
+        if path.is_dir() {
+            collect(&path, files);
+        } else {
+            println!("cargo:rerun-if-changed={}", path.display());
+            files.push(path);
+        }
+    }
+}

{sqlty-0.1.0 → sqlty-0.2.0}/rust/crates/sqlty-ext/src/lib.rs

@@ -52,6 +52,7 @@ type ParamTuple = (
     Option<String>,
     Option<bool>,
     bool,
+    Option<String>,
 );
 
 /// A parsed schema and the tables and views it could not parse.
@@ -296,6 +297,14 @@ fn infer_type(
     Ok(py.detach(|| analyzer::infer_type(sql, dialect, schema(schema_sql, dialect).as_deref()))?)
 }
 
+include!(concat!(env!("OUT_DIR"), "/skills.rs"));
+
+/// The files of the Agent Skills, as `(path, text)` with paths like `sqlty/SKILL.md`.
+#[pyfunction]
+fn skills() -> Vec<(&'static str, &'static str)> {
+    SKILLS.to_vec()
+}
+
 /// Result columns of a query as `(name, python_type, sql_type)` tuples.
 ///
 /// Returns None when the query returns no rows or doesn't parse; unknown types are None.
@@ -453,6 +462,7 @@ fn analyze_params(
                     param.sql_type,
                     nullable(param.nullability),
                     param.cast,
+                    param.untyped_sql_type,
                 )
             })
             .collect(),
@@ -483,7 +493,8 @@ fn name_rules() -> Vec<&'static str> {
 
 /// Why a query has untyped columns, or names what it cannot, as `(rule, message)` pairs:
 /// `unknown-table`, `unknown-column`, `ambiguous-column`, `unknown-function`,
-/// `unknown-type`, `unsupported-syntax`, `insert-missing-column` and `ungrouped-column`.
+/// `unknown-type`, `unsupported-syntax`, `insert-missing-column`, `insert-value-count` and
+/// `ungrouped-column`.
 /// Tables, columns and
 /// ambiguity are only judged with a schema.
 ///
@@ -821,6 +832,7 @@ fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(check_source, m)?)?;
     m.add_function(wrap_pyfunction!(wrapped_queries, m)?)?;
     m.add_function(wrap_pyfunction!(query_sites, m)?)?;
+    m.add_function(wrap_pyfunction!(skills, m)?)?;
     Ok(())
 }
 

{sqlty-0.1.0 → sqlty-0.2.0}/rust/crates/sqlty-python/src/checker.rs

@@ -410,7 +410,7 @@ impl Checker<'_> {
 
     /// `untyped-query`, `stale-type` and the literal rules, against the inferred row type.
     fn annotation(&mut self, call: &Call, sql_content: &str, line: usize) {
-        let annotated = &self.scan.source()[call.annotation.clone()];
+        let annotated = call.row_type(self.scan.source());
         let wrapper = if call.template {
             self.options.style.template_name()
         } else {
@@ -437,10 +437,28 @@ impl Checker<'_> {
             return;
         }
 
+        if is_scalar(annotated) && self.rules.is_enabled(Rule::NarrowType) {
+            if let Some(current) = self
+                .infer(sql_content)
+                .map(|current| self.spelling.respell(current))
+                .filter(|current| current.starts_with("tuple["))
+            {
+                let wrapper = if call.template { "SQLTemplate" } else { "SQL" };
+                self.report_fix(
+                    Rule::NarrowType,
+                    format!("{wrapper}[{annotated}] should be {wrapper}[{current}]: a row is never a single value"),
+                    line,
+                    vec![Edit::new(call.annotation.clone(), current)],
+                );
+            }
+            return;
+        }
         let literals = self.rules.is_enabled(Rule::LiteralMismatch)
             || self.rules.is_enabled(Rule::RedundantLiteral);
         if !(annotated.starts_with("tuple[")
-            && (self.rules.is_enabled(Rule::StaleType) || literals))
+            && (self.rules.is_enabled(Rule::StaleType)
+                || self.rules.is_enabled(Rule::NarrowType)
+                || literals))
         {
             return;
         }
@@ -448,9 +466,14 @@ impl Checker<'_> {
             .infer(sql_content)
             .map(|current| self.spelling.respell(current))
         {
-            if !refines_tuple(annotated, &current) {
+            let spelled = spell_unions(annotated);
+            if !refines_tuple(&spelled, &current) {
                 self.report_fix(
-                    Rule::StaleType,
+                    if admits_tuple(&spelled, &current) {
+                        Rule::StaleType
+                    } else {
+                        Rule::NarrowType
+                    },
                     format!(
                         "{}[{annotated}] should be {}[{current}]",
                         if call.template { "SQLTemplate" } else { "SQL" },
@@ -460,7 +483,7 @@ impl Checker<'_> {
                     vec![Edit::new(call.annotation.clone(), current.clone())],
                 );
             }
-            for (rule, message) in literal_findings(annotated, &current) {
+            for (rule, message) in literal_findings(&spelled, &current) {
                 self.report(rule, message, line);
             }
         }
@@ -683,13 +706,39 @@ pub fn wrapped_queries(source: &str, style: &ImportStyle) -> Vec<(usize, String,
             });
             (
                 scan.lines.line_at(call.span.start),
-                source[call.annotation.clone()].to_string(),
+                call.row_type(source).to_string(),
                 query,
             )
         })
         .collect()
 }
 
+/// Whether `annotated` is a builtin scalar or collection, such as `int` or `list[str]`:
+/// a driver returns each row as a tuple, a dict or an instance of a row class.
+fn is_scalar(annotated: &str) -> bool {
+    let members = split_top(annotated, '|');
+    members.iter().any(|member| member.trim() != "None")
+        && members.iter().all(|member| {
+            let base = member.trim().split('[').next().unwrap_or_default();
+            matches!(
+                base.strip_prefix("typing.").unwrap_or(base),
+                "None"
+                    | "int"
+                    | "str"
+                    | "float"
+                    | "bool"
+                    | "bytes"
+                    | "complex"
+                    | "list"
+                    | "set"
+                    | "frozenset"
+                    | "List"
+                    | "Set"
+                    | "FrozenSet"
+            )
+        })
+}
+
 /// The items of a `tuple[...]` type, split at its top-level commas.
 fn tuple_items(ty: &str) -> Option<Vec<&str>> {
     let inner = ty.strip_prefix("tuple[")?.strip_suffix(']')?;
@@ -755,6 +804,69 @@ fn split_top(text: &str, sep: char) -> Vec<&str> {
     parts
 }
 
+/// The members of a tuple item, with `Optional[X]`, `Union[A, B]` and a quoted annotation
+/// spelled out: `Optional[str]` and `"str | None"` are `["str", "None"]`.
+fn union_members(item: &str) -> Vec<&str> {
+    let parts = split_top(item, '|');
+    if parts.len() > 1 {
+        return parts.into_iter().flat_map(union_members).collect();
+    }
+    let item = item.trim();
+    let quoted = ['"', '\''].iter().find_map(|&quote| {
+        item.strip_prefix(quote)
+            .and_then(|rest| rest.strip_suffix(quote))
+    });
+    if let Some(inner) = quoted {
+        return union_members(inner);
+    }
+    let bare = item.strip_prefix("typing.").unwrap_or(item);
+    if let Some(inner) = bare
+        .strip_prefix("Optional[")
+        .and_then(|rest| rest.strip_suffix(']'))
+    {
+        let mut members = union_members(inner);
+        members.push("None");
+        return members;
+    }
+    if let Some(inner) = bare
+        .strip_prefix("Union[")
+        .and_then(|rest| rest.strip_suffix(']'))
+    {
+        return split_top(inner, ',')
+            .into_iter()
+            .flat_map(union_members)
+            .collect();
+    }
+    vec![item]
+}
+
+/// `annotated` with each `Optional[X]`, `Union[A, B]` or quoted item spelled `A | B | None`,
+/// as sqlty writes it.
+fn spell_unions(annotated: &str) -> String {
+    let Some(items) = tuple_items(annotated) else {
+        return annotated.to_string();
+    };
+    let items: Vec<String> = items
+        .iter()
+        .map(|item| {
+            let members = union_members(item);
+            let mut spelled: Vec<&str> = members.iter().copied().filter(|m| *m != "None").collect();
+            if spelled.len() < members.len() {
+                spelled.push("None");
+            }
+            spelled.join(" | ")
+        })
+        .collect();
+    format!("tuple[{}]", items.join(", "))
+}
+
+/// Whether two tuple items are the same union, in any order and spelling.
+fn same_union(annotated: &str, inferred: &str) -> bool {
+    let (ours, theirs) = (union_members(annotated), union_members(inferred));
+    ours.iter().all(|member| theirs.contains(member))
+        && theirs.iter().all(|member| ours.contains(member))
+}
+
 fn literal_member(text: &str) -> Option<Lit> {
     let Some(quote) = text.chars().next().filter(|c| matches!(c, '\'' | '"')) else {
         return text.parse().ok().map(Lit::Int);
@@ -929,6 +1041,7 @@ pub(crate) fn refines_tuple(annotated: &str, inferred: &str) -> bool {
             ours.iter().zip(&theirs).all(|(a, i)| {
                 let base = i.split('[').next().unwrap_or(i);
                 a == i
+                    || same_union(a, i)
                     || covers_literal(a, i)
                     || literal_pair(a, i).is_some_and(|pair| pair.same_nullability)
                     || *i == "typing.Any"
@@ -943,6 +1056,45 @@ pub(crate) fn refines_tuple(annotated: &str, inferred: &str) -> bool {
     }
 }
 
+/// Whether every row of the inferred `tuple[...]` is a row of the annotated one: `str | None`
+/// admits `str`, `str` admits `Literal['a']`, and `object` or `typing.Any` admit anything.
+fn admits_tuple(annotated: &str, inferred: &str) -> bool {
+    fn literal_class(member: &str) -> Option<&'static str> {
+        let values = member
+            .strip_prefix("typing.")
+            .unwrap_or(member)
+            .strip_prefix("Literal[")?
+            .strip_suffix(']')?;
+        let values = split_top(values, ',');
+        if values.iter().all(|v| v.starts_with(['\'', '"'])) {
+            Some("str")
+        } else if values.iter().all(|v| matches!(*v, "True" | "False")) {
+            Some("bool")
+        } else if values.iter().all(|v| v.parse::<i64>().is_ok()) {
+            Some("int")
+        } else {
+            None
+        }
+    }
+    fn admits(annotated: &str, inferred: &str) -> bool {
+        let members = union_members(annotated);
+        members
+            .iter()
+            .any(|m| matches!(*m, "typing.Any" | "Any" | "object"))
+            || split_top(inferred, '|').iter().all(|member| {
+                members.contains(member)
+                    || literal_class(member).is_some_and(|class| members.contains(&class))
+            })
+    }
+    match (tuple_items(annotated), tuple_items(inferred)) {
+        (Some(ours), Some(theirs)) => match ours.as_slice() {
+            [each, "..."] => theirs.iter().all(|i| admits(each, i)),
+            _ => ours.len() == theirs.len() && ours.iter().zip(&theirs).all(|(a, i)| admits(a, i)),
+        },
+        _ => false,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1094,9 +1246,35 @@ mod tests {
             false,
             &[],
         );
-        let stale_types: Vec<_> = diags.iter().filter(|d| d.rule == Rule::StaleType).collect();
-        assert_eq!(stale_types.len(), 1);
-        assert!(stale_types[0].message.contains("tuple[int]"));
+        let narrow: Vec<_> = diags
+            .iter()
+            .filter(|d| d.rule == Rule::NarrowType)
+            .collect();
+        assert_eq!(narrow.len(), 1);
+        assert!(narrow[0].message.contains("tuple[int]"));
+    }
+
+    #[test]
+    fn test_wider_annotation_is_stale_not_narrow() {
+        for (annotated, inferred, admitted) in [
+            ("tuple[str | None]", "tuple[str]", true),
+            ("tuple[object, typing.Any]", "tuple[int | None, str]", true),
+            (
+                "tuple[str, int, bool]",
+                "tuple[Literal['a', \"b\"], typing.Literal[-1, 2], Literal[True]]",
+                true,
+            ),
+            ("tuple[str]", "tuple[str | None]", false),
+            ("tuple[int]", "tuple[int, str]", false),
+            ("tuple[int]", "tuple[Literal['a']]", false),
+            ("tuple[int]", "dict[str, int]", false),
+        ] {
+            assert_eq!(
+                admits_tuple(annotated, inferred),
+                admitted,
+                "{annotated} {inferred}"
+            );
+        }
     }
 
     #[test]

{sqlty-0.1.0 → sqlty-0.2.0}/rust/crates/sqlty-python/src/fixer.rs

@@ -19,12 +19,13 @@ use crate::rules::{Rule, RuleConfig};
 use crate::scan::Scan;
 
 /// The rules whose diagnostics carry a fix.
-const FIXABLE: [Rule; 6] = [
+const FIXABLE: [Rule; 7] = [
     Rule::InlineSqlComment,
     Rule::MysqlSqlMarker,
     Rule::StaleRewrite,
     Rule::SelectStar,
     Rule::StaleType,
+    Rule::NarrowType,
     Rule::UntypedQuery,
 ];
 
@@ -78,7 +79,7 @@ pub fn fix_source(
         for edit in applied {
             match rule_at[&(edit.range.start, edit.range.end)] {
                 Rule::StaleRewrite => wrapped.push(edit.replacement),
-                Rule::StaleType | Rule::UntypedQuery => {
+                Rule::StaleType | Rule::NarrowType | Rule::UntypedQuery => {
                     introduced.insert(edit.replacement);
                 }
                 _ => {}

{sqlty-0.1.0 → sqlty-0.2.0}/rust/crates/sqlty-python/src/rules.rs

@@ -38,8 +38,10 @@ pub enum Rule {
     SelectStarNoSchema,
     /// A `--sql` string that is not wrapped in `SQL[T](...)`.
     StaleRewrite,
-    /// A `SQL[tuple[...]]` that neither matches nor refines the inferred row type.
+    /// A `SQL[tuple[...]]` wider than the inferred row type: it admits every row.
     StaleType,
+    /// A `SQL[tuple[...]]` that does not admit every row the query returns.
+    NarrowType,
     /// A `--sql` marker under MySQL, which rejects it.
     MysqlSqlMarker,
     /// `"--sql SELECT ..."`: the whole query is a SQL comment.
@@ -66,7 +68,7 @@ pub enum Rule {
 
 impl Rule {
     /// Every rule.
-    pub const ALL: [Rule; 32] = [
+    pub const ALL: [Rule; 34] = [
         Rule::ColumnCountMismatch,
         Rule::ColumnTypeMismatch,
         Rule::ColumnNameMismatch,
@@ -81,6 +83,7 @@ impl Rule {
         Rule::SelectStarNoSchema,
         Rule::StaleRewrite,
         Rule::StaleType,
+        Rule::NarrowType,
         Rule::MysqlSqlMarker,
         Rule::InlineSqlComment,
         Rule::FstringSkipped,
@@ -98,6 +101,7 @@ impl Rule {
         Rule::Name(NameRule::UnknownType),
         Rule::Name(NameRule::UnsupportedSyntax),
         Rule::Name(NameRule::InsertMissingColumn),
+        Rule::Name(NameRule::InsertValueCount),
         Rule::Name(NameRule::UngroupedColumn),
     ];
 
@@ -118,6 +122,7 @@ impl Rule {
             Rule::SelectStarNoSchema => "select-star-no-schema",
             Rule::StaleRewrite => "stale-rewrite",
             Rule::StaleType => "stale-type",
+            Rule::NarrowType => "narrow-type",
             Rule::MysqlSqlMarker => "mysql-sql-marker",
             Rule::InlineSqlComment => "inline-sql-comment",
             Rule::FstringSkipped => "fstring-skipped",
@@ -149,12 +154,14 @@ impl Rule {
             | Rule::LiteralMismatch
             | Rule::ParamCountMismatch
             | Rule::ParamTypeMismatch
+            | Rule::NarrowType
             | Rule::SelectStarNoSchema
             | Rule::Name(
                 NameRule::UnknownTable
                 | NameRule::UnknownColumn
                 | NameRule::AmbiguousColumn
                 | NameRule::InsertMissingColumn
+                | NameRule::InsertValueCount
                 | NameRule::UngroupedColumn,
             ) => Severity::Error,
             Rule::ColumnNameMismatch
@@ -310,6 +317,8 @@ mod tests {
         let config = RuleConfig::default();
         assert_eq!(config.severity(Rule::SelectStarNoSchema), Severity::Error);
         assert_eq!(config.severity(Rule::StaleRewrite), Severity::Warn);
+        assert_eq!(config.severity(Rule::StaleType), Severity::Warn);
+        assert_eq!(config.severity(Rule::NarrowType), Severity::Error);
         assert_eq!(config.severity(Rule::UnparsedQuery), Severity::Warn);
         assert_eq!(config.severity(Rule::RedundantOptional), Severity::Ignore);
         assert_eq!(

{sqlty-0.1.0 → sqlty-0.2.0}/rust/crates/sqlty-python/src/tokens.rs

@@ -382,6 +382,19 @@ impl Call {
         any_calls.binary_search(&self.span.start).is_ok()
     }
 
+    /// `T` as a type: the content of a string literal (a forward reference, `SQL["User"]`),
+    /// else its source.
+    pub(crate) fn row_type<'a>(&self, source: &'a str) -> &'a str {
+        let written = source[self.annotation.clone()].trim();
+        ['"', '\'']
+            .into_iter()
+            .find_map(|quote| {
+                let inner = written.strip_prefix(quote)?.strip_suffix(quote)?;
+                (!inner.contains([quote, '\\'])).then_some(inner.trim())
+            })
+            .unwrap_or(written)
+    }
+
     /// The source of the argument's literals, from the first to the last.
     pub(crate) fn argument<'a>(&self, source: &'a str) -> &'a str {
         &source[self.strings[0].start..self.strings[self.strings.len() - 1].end]

{sqlty-0.1.0 → sqlty-0.2.0}/rust/crates/sqlty-sql/build.rs

@@ -38,7 +38,9 @@ fn collect(dir: &Path, files: &mut Vec<PathBuf>) {
         let path = entry.path();
         if path.is_dir() {
             collect(&path, files);
-        } else if path.to_string_lossy().ends_with(".inference.toml") {
+        } else if path.to_string_lossy().ends_with(".inference.toml")
+            || path.ends_with("rules/dialects.toml")
+        {
             files.push(path);
         }
     }