sqlty 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlty
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

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

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

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

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.2.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.2.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.0 → sqlty-0.2.1}/rust/crates/sqlty-ext/src/lib.rs

@@ -187,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 {
@@ -294,7 +294,20 @@ 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"));
@@ -320,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| {
@@ -349,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);
@@ -385,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| {
@@ -448,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(
@@ -509,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()
@@ -528,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()
@@ -544,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>>(
@@ -569,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.
@@ -579,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...").
@@ -603,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))
@@ -619,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))
     })
@@ -649,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)?;
@@ -675,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
@@ -693,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.
@@ -737,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)?;
@@ -767,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))
     })
@@ -795,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()
@@ -808,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>()?;

{sqlty-0.2.0 → sqlty-0.2.1}/rust/crates/sqlty-sql/Cargo.toml

@@ -13,6 +13,7 @@ workspace = true
 
 [dependencies]
 sqlparser.workspace = true
+recursive.workspace = true
 regex.workspace = true
 rustc-hash.workspace = true
 thiserror.workspace = true

{sqlty-0.2.0 → sqlty-0.2.1}/rust/crates/sqlty-sql/src/analyzer/api.rs

@@ -10,7 +10,7 @@ use super::dialect::SqlDialect;
 use super::dml::statement_returns_rows;
 use super::expr::from_sql_type;
 use super::names::alias_name;
-use super::preprocess::{parse_first, parse_query, parser_input};
+use super::preprocess::{parse_first, parse_query, parser_input, too_deep, MAX_DEPTH};
 use super::query::{Analyzer, Column};
 use super::{Inferred, Schema, SchemaData, SkippedObject, ANY};
 
@@ -166,6 +166,9 @@ pub fn parse_error(sql: &str, dialect: &str) -> Option<String> {
     let input = parser_input(sql, dialect);
     Some(
         match Parser::parse_sql(dialect.parser_dialect().as_ref(), &input) {
+            Ok(stmts) if too_deep(&stmts) => {
+                format!("expressions nest more than {MAX_DEPTH} levels deep")
+            }
             Ok(_) => "unsupported in this dialect".to_string(),
             Err(err) => {
                 let text = err.to_string();

{sqlty-0.2.0 → sqlty-0.2.1}/rust/crates/sqlty-sql/src/analyzer/dml.rs

@@ -24,12 +24,24 @@ pub(super) fn statement_returns_rows(stmt: &Statement) -> bool {
             | SetExpr::Update(inner)
             | SetExpr::Delete(inner)
             | SetExpr::Merge(inner) => statement_returns_rows(inner),
-            _ => true,
+            body => !selects_into(body),
         },
         _ => returning(stmt).is_some(),
     }
 }
 
+/// Whether a query stores its rows instead of returning them: PostgreSQL's
+/// `SELECT ... INTO table`, MySQL's `SELECT ... INTO @variable`. Only the first `SELECT` of
+/// a set operation may have `INTO`.
+pub(super) fn selects_into(body: &SetExpr) -> bool {
+    match body {
+        SetExpr::Select(select) => select.into.is_some(),
+        SetExpr::SetOperation { left, .. } => selects_into(left),
+        SetExpr::Query(query) => selects_into(&query.body),
+        _ => false,
+    }
+}
+
 /// The non-empty top-level RETURNING list of INSERT/UPDATE/DELETE/MERGE.
 pub(super) fn returning(stmt: &Statement) -> Option<&[SelectItem]> {
     let items = match stmt {
@@ -218,17 +230,16 @@ impl Analyzer<'_> {
                 let TableObject::TableName(name) = &insert.table else {
                     return self.facts.clone();
                 };
+                let table = self
+                    .schema
+                    .table(&table_key(name, self.dialect))
+                    .unwrap_or_default();
                 let columns: Vec<String> = if insert.columns.is_empty() {
-                    self.schema
-                        .table(&table_key(name, self.dialect))
-                        .map(|columns| {
-                            columns
-                                .iter()
-                                .filter(|c| !c.invisible)
-                                .map(|c| c.ident.clone())
-                                .collect()
-                        })
-                        .unwrap_or_default()
+                    table
+                        .iter()
+                        .filter(|c| !c.invisible)
+                        .map(|c| c.ident.clone())
+                        .collect()
                 } else {
                     insert
                         .columns
@@ -237,16 +248,57 @@ impl Analyzer<'_> {
                         .map(|ident| ident.value.clone())
                         .collect()
                 };
+                // `None` for `DEFAULT VALUES`, which writes no column.
                 let values = insert
                     .source
                     .as_deref()
-                    .and_then(|source| quiet.query_columns(source).ok().flatten())
-                    .unwrap_or_default();
+                    .map(|source| quiet.query_columns(source).ok().flatten());
+                let written = match &values {
+                    None => Some(0),
+                    Some(values) => values.as_ref().map(Vec::len),
+                };
+                // A column the INSERT leaves out gets its DEFAULT; `VALUES` shorter than the
+                // table leaves out the last columns.
+                let listed: Option<Vec<String>> = if insert.columns.is_empty() {
+                    written.map(|count| {
+                        table
+                            .iter()
+                            .filter(|c| !c.invisible)
+                            .take(count)
+                            .map(|c| c.name.clone())
+                            .collect()
+                    })
+                } else {
+                    Some(
+                        insert
+                            .columns
+                            .iter()
+                            .filter_map(|column| column.0.last().and_then(|part| part.as_ident()))
+                            .map(|ident| fold(ident, self.dialect))
+                            .collect(),
+                    )
+                };
+                let defaulted = listed.into_iter().flat_map(|listed| {
+                    table
+                        .iter()
+                        .filter(move |c| !listed.contains(&c.name))
+                        .filter(|c| {
+                            c.default.as_ref().is_some_and(|default| {
+                                non_null(quiet.nullability(
+                                    default,
+                                    &Scope::new(),
+                                    &Facts::default(),
+                                ))
+                            })
+                        })
+                        .map(|c| c.name.clone())
+                });
                 let inserted: Vec<String> = columns
                     .into_iter()
-                    .zip(&values)
+                    .zip(values.flatten().unwrap_or_default())
                     .filter(|(_, value)| non_null(value.nullability))
                     .map(|(column, _)| column)
+                    .chain(defaulted)
                     .collect();
                 match &insert.on {
                     None

{sqlty-0.2.0 → sqlty-0.2.1}/rust/crates/sqlty-sql/src/analyzer/expr.rs

@@ -5,7 +5,7 @@ use sqlparser::ast::{
     FunctionArguments, Ident, ObjectName, Subscript, UnaryOperator, Value,
 };
 
-use crate::catalog::{fold, FunctionReturn};
+use crate::catalog::{fold, FunctionReturn, SchemaColumn};
 use crate::diagnostics::NameRule;
 
 use super::dialect::SqlDialect;
@@ -102,16 +102,12 @@ impl<'a> Analyzer<'a> {
     /// the composite's name when it declares no such field. In PostgreSQL each table is
     /// also the composite type of its rows.
     fn field_typed(&self, composite: Option<&str>, field: &Ident) -> Result<Typed, String> {
-        let postgres = self.dialect == SqlDialect::Postgres;
-        let Some((name, fields)) = composite.map(str::to_lowercase).and_then(|name| {
-            let fields = self
-                .schema
-                .composite(&name)
-                .or_else(|| postgres.then(|| self.schema.table(&name)).flatten())?;
-            Some((name, fields))
-        }) else {
+        let Some((name, fields)) = composite.and_then(|name| self.composite_fields(name)) else {
             return Ok(Typed::UNKNOWN);
         };
+        if is_field_star(field) {
+            return Ok(Typed::UNKNOWN);
+        }
         let field = fold(field, self.dialect);
         match fields.iter().find(|col| col.name == field) {
             Some(col) => Ok(col.typed(self.dialect)),
@@ -119,6 +115,18 @@ impl<'a> Analyzer<'a> {
         }
     }
 
+    /// The lower-case name and the fields of the composite type `composite`, when the schema
+    /// declares it. In PostgreSQL each table is also the composite type of its rows.
+    pub(super) fn composite_fields(&self, composite: &str) -> Option<(String, &[SchemaColumn])> {
+        let name = composite.to_lowercase();
+        let fields = self.schema.composite(&name).or_else(|| {
+            (self.dialect == SqlDialect::Postgres)
+                .then(|| self.schema.table(&name))
+                .flatten()
+        })?;
+        Some((name, fields))
+    }
+
     /// Whether `data_type` is, or is an array of, a domain, enum or composite type the
     /// schema defines.
     fn defines_type(&self, data_type: &DataType) -> bool {
@@ -196,6 +204,7 @@ impl<'a> Analyzer<'a> {
         }
     }
 
+    #[recursive::recursive]
     pub(super) fn expr(&self, expr: &Expr, scope: &Scope) -> Inferred<Typed> {
         match expr {
             Expr::Cast { data_type, .. } => Ok(self.cast_typed(data_type)),
@@ -235,10 +244,13 @@ impl<'a> Analyzer<'a> {
                 expr: inner,
             } => match crate::values::constant(expr) {
                 Some(negative) => Ok(constant(negative)),
-                None if self.prefix_rule(op, inner, scope)?.is_some() => {
-                    self.prefix_op(op, inner, scope)
+                None => {
+                    let typed = self.expr(inner, scope)?;
+                    Ok(match self.prefix_rule_of(op, &typed) {
+                        Some(rule) => self.prefixed(rule, typed),
+                        None => strip(typed, self.dialect),
+                    })
                 }
-                None => Ok(strip(self.expr(inner, scope)?, self.dialect)),
             },
             Expr::AtTimeZone { timestamp, .. } if self.dialect == SqlDialect::Postgres => {
                 // `timestamp AT TIME ZONE zone` is a `timestamptz` and vice versa; a time
@@ -252,17 +264,14 @@ impl<'a> Analyzer<'a> {
                 })
             }
             Expr::Ceil { expr: inner, .. } | Expr::Floor { expr: inner, .. } => {
+                let typed = self.expr(inner, scope)?;
                 let returns = match self.dialect {
                     SqlDialect::MySql => Returns::Integral,
                     // SQLite returns an integer argument as it is.
-                    SqlDialect::Sqlite
-                        if self.expr(inner, scope)?.python.as_deref() == Some("int") =>
-                    {
-                        Returns::Arg(0)
-                    }
+                    SqlDialect::Sqlite if typed.python.as_deref() == Some("int") => Returns::Arg(0),
                     _ => Returns::Real,
                 };
-                self.function_type(returns, &[inner], scope)
+                self.function_type_of(returns, &[inner], &[Some(typed), None], scope)
             }
             Expr::Extract { .. } if self.dialect == SqlDialect::Postgres => {
                 Ok(from_sql_type("DECIMAL", self.dialect))
@@ -593,7 +602,9 @@ impl<'a> Analyzer<'a> {
                     )
                 }
                 FunctionType::Code => self.sum(argument()?, arg, scope)?,
-                FunctionType::Returns(returns) => self.function_type(returns, &args, scope)?,
+                FunctionType::Returns(returns) => {
+                    self.function_type_of(returns, &args, &typed, scope)?
+                }
             });
         }
         match name.as_str() {
@@ -648,6 +659,11 @@ pub(super) fn is_binary_charset(charset: &ObjectName) -> bool {
     charset.to_string().eq_ignore_ascii_case("binary")
 }
 
+/// Whether `field` is the `"*"` that respell writes for PostgreSQL's `(composite).*`.
+pub(super) fn is_field_star(field: &Ident) -> bool {
+    field.value == "*" && field.quote_style == Some('"')
+}
+
 #[cfg(test)]
 mod tests {
     use super::super::test_support::reports;

{sqlty-0.2.0 → sqlty-0.2.1}/rust/crates/sqlty-sql/src/analyzer/functions.rs

@@ -125,9 +125,22 @@ impl<'a> Analyzer<'a> {
         args: &[&Expr],
         scope: &Scope,
     ) -> Inferred<Typed> {
-        let arg = |i: usize| match args.get(i) {
-            Some(arg) => self.expr(arg, scope),
-            None => Ok(Typed::UNKNOWN),
+        self.function_type_of(returns, args, &[None, None], scope)
+    }
+
+    /// [`Self::function_type`] given the types of the first two arguments already inferred,
+    /// which are not inferred again.
+    pub(super) fn function_type_of(
+        &self,
+        returns: Returns,
+        args: &[&Expr],
+        known: &RuleArguments,
+        scope: &Scope,
+    ) -> Inferred<Typed> {
+        let arg = |i: usize| match (known.get(i), args.get(i)) {
+            (Some(Some(typed)), _) => Ok(typed.clone()),
+            (_, Some(arg)) => self.expr(arg, scope),
+            (_, None) => Ok(Typed::UNKNOWN),
         };
         let sql = |name: &str| Ok(from_sql_type(name, self.dialect));
         match returns {