sqlty 0.1.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlty
-Version: 0.1.0
+Version: 0.2.1
 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.1}/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.1}/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.1}/rust/Cargo.lock

@@ -614,7 +614,7 @@ dependencies = [
 
 [[package]]
 name = "sqlty-bench"
-version = "0.1.0"
+version = "0.2.1"
 dependencies = [
  "criterion",
  "sqlty-python",
@@ -623,17 +623,19 @@ dependencies = [
 
 [[package]]
 name = "sqlty-core"
-version = "0.1.0"
+version = "0.2.1"
 dependencies = [
  "pyo3",
+ "recursive",
  "sqlty-python",
  "sqlty-sql",
+ "stacker",
  "thiserror",
 ]
 
 [[package]]
 name = "sqlty-python"
-version = "0.1.0"
+version = "0.2.1"
 dependencies = [
  "regex",
  "sqlty-sql",
@@ -642,9 +644,10 @@ dependencies = [
 
 [[package]]
 name = "sqlty-sql"
-version = "0.1.0"
+version = "0.2.1"
 dependencies = [
  "insta",
+ "recursive",
  "regex",
  "rustc-hash",
  "serde",

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

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.2.1"
 edition = "2021"
 description = "Rust engine of sqlty: SQL type inference and Python source rewriting"
 license = "MIT"
@@ -15,6 +15,7 @@ rust-version = "1.88"
 pyo3 = { version = "0.29", features = ["extension-module"] }
 sqlparser = { version = "0.63", features = ["visitor"] }
 regex = "1"
+recursive = "0.1"
 rustc-hash = "2"
 thiserror = "2"
 insta = "1.49"

{sqlty-0.1.0 → sqlty-0.2.1}/rust/crates/sqlty-ext/Cargo.toml

@@ -19,4 +19,6 @@ crate-type = ["cdylib"]
 pyo3.workspace = true
 sqlty-sql.workspace = true
 sqlty-python.workspace = true
+recursive.workspace = true
+stacker = "0.1"
 thiserror.workspace = true

sqlty-0.2.1/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.1}/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.
@@ -186,7 +187,7 @@ fn load_schema(
     let dialect = dialect.0;
     let overrides = analyzer::TypeOverrides::new(&types.unwrap_or_default(), dialect)
         .map_err(PyValueError::new_err)?;
-    let loaded = py.detach(|| {
+    let loaded = detach(py, || {
         let (schema, skipped) = if overrides.is_empty() {
             analyzer::load_schema_with_skipped(schema_sql, dialect)
         } else {
@@ -293,7 +294,28 @@ fn infer_type(
     schema_sql: Option<SchemaArg>,
 ) -> Result<Option<String>, Error> {
     let dialect = dialect.0;
-    Ok(py.detach(|| analyzer::infer_type(sql, dialect, schema(schema_sql, dialect).as_deref()))?)
+    Ok(detach(py, || {
+        analyzer::infer_type(sql, dialect, schema(schema_sql, dialect).as_deref())
+    })?)
+}
+
+/// The stack the analyzer's recursion keeps free: it moves to a new stack of
+/// [`STACK_SEGMENT`] when less is left, so an expression nested `MAX_DEPTH` (1000) levels
+/// deep fits whatever thread calls it.
+const STACK_RED_ZONE: usize = 2 << 20;
+const STACK_SEGMENT: usize = 16 << 20;
+
+/// Runs `f` without the GIL, with at least [`STACK_RED_ZONE`] of stack.
+fn detach<T: Send, F: Send + FnOnce() -> T>(py: Python<'_>, f: F) -> T {
+    py.detach(|| stacker::maybe_grow(STACK_RED_ZONE, STACK_SEGMENT, f))
+}
+
+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.
@@ -311,7 +333,7 @@ fn analyze_select(
     schema_sql: Option<SchemaArg>,
 ) -> Result<Option<Vec<ColumnTuple>>, Error> {
     let dialect = dialect.0;
-    let columns = py.detach(|| {
+    let columns = detach(py, || {
         analyzer::analyze_select(sql, dialect, schema(schema_sql, dialect).as_deref())
     })?;
     Ok(columns.map(|columns| {
@@ -340,7 +362,7 @@ fn explain_select(
     schema_sql: Option<SchemaArg>,
 ) -> Option<Vec<ColumnRulesTuple>> {
     let dialect = dialect.0;
-    let columns = py.detach(|| {
+    let columns = detach(py, || {
         analyzer::explain_select(sql, dialect, schema(schema_sql, dialect).as_deref())
     })?;
     let tuple = |rule: analyzer::RuleRef| (rule.id, rule.reference, rule.reasoning);
@@ -376,7 +398,7 @@ fn analyze_columns(
     schema_sql: Option<SchemaArg>,
 ) -> Result<Option<Vec<NullableColumnTuple>>, Error> {
     let dialect = dialect.0;
-    let columns = py.detach(|| {
+    let columns = detach(py, || {
         analyzer::analyze_select(sql, dialect, schema(schema_sql, dialect).as_deref())
     })?;
     Ok(columns.map(|columns| {
@@ -439,7 +461,7 @@ fn analyze_params(
     schema_sql: Option<SchemaArg>,
 ) -> Option<Vec<ParamTuple>> {
     let dialect = dialect.0;
-    let params = py.detach(|| {
+    let params = detach(py, || {
         analyzer::analyze_params(sql, dialect, schema(schema_sql, dialect).as_deref())
     })?;
     Some(
@@ -453,6 +475,7 @@ fn analyze_params(
                     param.sql_type,
                     nullable(param.nullability),
                     param.cast,
+                    param.untyped_sql_type,
                 )
             })
             .collect(),
@@ -483,7 +506,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.
 ///
@@ -498,7 +522,7 @@ fn query_diagnostics(
     schema_sql: Option<SchemaArg>,
 ) -> Vec<(String, String)> {
     let dialect = dialect.0;
-    py.detach(|| {
+    detach(py, || {
         analyzer::analyze_with_diagnostics(sql, dialect, schema(schema_sql, dialect).as_deref())
             .1
             .into_iter()
@@ -517,7 +541,7 @@ fn schema_skipped_tables(
     dialect: DialectArg,
 ) -> Vec<String> {
     let dialect = dialect.0;
-    py.detach(|| skipped_objects(schema_sql, dialect, Some("table")))
+    detach(py, || skipped_objects(schema_sql, dialect, Some("table")))
         .into_iter()
         .map(|(_, name)| name)
         .collect()
@@ -533,7 +557,7 @@ fn schema_skipped_objects(
     dialect: DialectArg,
 ) -> Vec<(String, String)> {
     let dialect = dialect.0;
-    py.detach(|| skipped_objects(schema_sql, dialect, None))
+    detach(py, || skipped_objects(schema_sql, dialect, None))
 }
 
 fn skipped_objects<S: AsRef<str>>(
@@ -558,7 +582,7 @@ fn skipped_objects<S: AsRef<str>>(
 #[pyo3(signature = (sql, *, dialect = DialectArg::POSTGRES))]
 fn parse_error(py: Python<'_>, sql: &str, dialect: DialectArg) -> Option<String> {
     let dialect = dialect.0;
-    py.detach(|| analyzer::parse_error(sql, dialect))
+    detach(py, || analyzer::parse_error(sql, dialect))
 }
 
 /// Whether a query yields rows: a query, DML with RETURNING, or unparseable SQL.
@@ -568,7 +592,7 @@ fn parse_error(py: Python<'_>, sql: &str, dialect: DialectArg) -> Option<String>
 #[pyo3(signature = (sql, *, dialect = DialectArg::POSTGRES))]
 fn returns_rows(py: Python<'_>, sql: &str, dialect: DialectArg) -> bool {
     let dialect = dialect.0;
-    py.detach(|| analyzer::returns_rows(sql, dialect))
+    detach(py, || analyzer::returns_rows(sql, dialect))
 }
 
 /// Rewrite Python source: "--sql\n..." -> SQL[T]("--sql\n...").
@@ -592,7 +616,7 @@ fn rewrite_source(
     keep_lines: bool,
 ) -> Result<String, Error> {
     let dialect = dialect.0;
-    py.detach(|| {
+    detach(py, || {
         let schema = schema_for(source, schema_sql, dialect);
         let options = Options::new(dialect, schema.as_deref(), import_style, untyped)?;
         Ok(rewriter::rewrite_source_with(source, &options, keep_lines))
@@ -608,7 +632,7 @@ fn rewrite_source(
 #[pyfunction]
 #[pyo3(signature = (source, *, import_style = None))]
 fn strip_source(py: Python<'_>, source: &str, import_style: Option<&str>) -> Result<String, Error> {
-    py.detach(|| {
+    detach(py, || {
         let style = ImportStyle::parse(import_style)?;
         Ok(rewriter::strip_source(source, &style))
     })
@@ -638,7 +662,7 @@ fn fix_source(
     suppressed: Option<rewriter::Suppressed>,
 ) -> Result<String, Error> {
     let dialect = dialect.0;
-    py.detach(|| {
+    detach(py, || {
         let schema = schema_for(source, schema_sql, dialect);
         let options = Options::new(dialect, schema.as_deref(), import_style, untyped)?;
         let rules = RuleConfig::from_overrides(rules).map_err(ConfigError::from)?;
@@ -664,7 +688,9 @@ fn expand_star(
     schema_sql: Option<SchemaArg>,
 ) -> Option<String> {
     let dialect = dialect.0;
-    py.detach(|| analyzer::expand_star(sql, dialect, schema(schema_sql, dialect).as_deref()))
+    detach(py, || {
+        analyzer::expand_star(sql, dialect, schema(schema_sql, dialect).as_deref())
+    })
 }
 
 /// `(rule, message)` of `select-star` or `select-star-no-schema` for a query whose
@@ -682,8 +708,10 @@ fn select_star_finding(
     has_schema: bool,
 ) -> Option<(&'static str, String)> {
     let dialect = dialect.0;
-    py.detach(|| checker::select_star_finding(sql, dialect, has_schema))
-        .map(|(rule, message)| (rule.name(), message))
+    detach(py, || {
+        checker::select_star_finding(sql, dialect, has_schema)
+    })
+    .map(|(rule, message)| (rule.name(), message))
 }
 
 /// A finding of `check_source`, which Python reads as a dict.
@@ -726,7 +754,7 @@ fn check_source(
     any_calls: Vec<usize>,
 ) -> Result<Vec<DiagnosticOut>, Error> {
     let dialect = dialect.0;
-    py.detach(|| {
+    detach(py, || {
         let schema = schema_for(source, schema_sql, dialect);
         let options = Options::new(dialect, schema.as_deref(), import_style, untyped)?;
         let rules = RuleConfig::from_overrides(rules).map_err(ConfigError::from)?;
@@ -756,7 +784,7 @@ fn wrapped_queries(
     source: &str,
     import_style: Option<&str>,
 ) -> Result<Vec<(usize, String, Option<String>)>, Error> {
-    py.detach(|| {
+    detach(py, || {
         let style = ImportStyle::parse(import_style)?;
         Ok(checker::wrapped_queries(source, &style))
     })
@@ -784,7 +812,7 @@ fn query_sites(
     import_style: Option<&str>,
     any_calls: Vec<usize>,
 ) -> Result<Vec<(usize, String, String)>, Error> {
-    py.detach(|| {
+    detach(py, || {
         let style = ImportStyle::parse(import_style)?;
         Ok(checker::query_sites(source, &style, &any_calls)
             .into_iter()
@@ -797,6 +825,8 @@ fn query_sites(
 /// module runs without the GIL on free-threaded builds.
 #[pymodule(gil_used = false)]
 fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    recursive::set_minimum_stack_size(STACK_RED_ZONE);
+    recursive::set_stack_allocation_size(STACK_SEGMENT);
     m.add_function(wrap_pyfunction!(infer_type, m)?)?;
     m.add_function(wrap_pyfunction!(load_schema, m)?)?;
     m.add_class::<SchemaHandle>()?;
@@ -821,6 +851,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(())
 }