polyglot-sql-chio 0.12.2__tar.gz → 0.12.3__tar.gz

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.12.2"
+version = "0.12.3"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.12.2"
+version = "0.12.3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.12.2"
+version = "0.12.3"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.12.2"
+version = "0.12.3"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.12.2"
+version = "0.12.3"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.12.2"
+version = "0.12.3"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.12.2"
+version = "0.12.3"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/PKG-INFO

@@ -1,15 +1,12 @@
 Metadata-Version: 2.4
 Name: polyglot-sql-chio
-Version: 0.12.2
+Version: 0.12.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Database
@@ -18,7 +15,7 @@ Summary: Rust-powered SQL transpiler for more than 30 SQL dialects. Parse, gener
 Keywords: sql,transpiler,parser,dialect,database
 Home-Page: https://github.com/tobilg/polyglot
 License: MIT
-Requires-Python: >=3.9
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Documentation, https://polyglot.gh.tobilg.com
 Project-URL: Homepage, https://github.com/chio-labs/polyglot

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/crates/polyglot-sql/Cargo.toml

@@ -100,14 +100,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.12.2" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.12.3" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.12.2", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.12.3", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/crates/polyglot-sql/README.md

@@ -25,12 +25,12 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.12.2", default-features = false }
+polyglot-sql = { version = "0.12.3", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.12.2",
+    version = "0.12.3",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.12.2",
+    version = "0.12.3",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.12.2",
+    version = "0.12.3",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/crates/polyglot-sql/src/lineage.rs

@@ -714,13 +714,7 @@ fn expand_star_from_sources(
         let qual_normalized = normalize_cte_name(qual);
         for src in sources {
             if src.normalized == qual_normalized || src.alias.to_lowercase() == qual_normalized {
-                // Try CTE first
-                if let Some(cols) = resolved_ctes.get(&src.normalized) {
-                    expanded.extend(cols.iter().map(|c| (src.alias.clone(), c.clone())));
-                    return Some(expanded);
-                }
-                // Fall back to schema
-                if let Some(cols) = lookup_schema_columns(schema, &src.fq_name) {
+                if let Some(cols) = source_output_columns(src, resolved_ctes, schema) {
                     expanded.extend(cols.into_iter().map(|c| (src.alias.clone(), c)));
                     return Some(expanded);
                 }
@@ -735,15 +729,9 @@ fn expand_star_from_sources(
         // This matches sqlglot's behavior (raises SqlglotError when schema is missing).
         let mut any_expanded = false;
         for src in sources {
-            if let Some(cols) = resolved_ctes.get(&src.normalized) {
-                expanded.extend(cols.iter().map(|c| (src.alias.clone(), c.clone())));
-                any_expanded = true;
-            } else if let Some(cols) = lookup_schema_columns(schema, &src.fq_name) {
-                expanded.extend(cols.into_iter().map(|c| (src.alias.clone(), c)));
-                any_expanded = true;
-            } else {
-                return None;
-            }
+            let cols = source_output_columns(src, resolved_ctes, schema)?;
+            expanded.extend(cols.into_iter().map(|c| (src.alias.clone(), c)));
+            any_expanded = true;
         }
         if any_expanded {
             Some(expanded)
@@ -753,6 +741,57 @@ fn expand_star_from_sources(
     }
 }
 
+/// Output columns of a FROM/JOIN source, preferring resolved CTEs over the schema.
+fn source_output_columns(
+    src: &SourceInfo,
+    resolved_ctes: &HashMap<String, Vec<String>>,
+    schema: Option<&dyn Schema>,
+) -> Option<Vec<String>> {
+    match &src.relation {
+        SourceRelation::Plain => resolved_ctes
+            .get(&src.normalized)
+            .cloned()
+            .or_else(|| lookup_schema_columns(schema, &src.fq_name)),
+        SourceRelation::Pivot(pivot) if !pivot.unpivot => {
+            let input = pivot_input_columns(&pivot.this, resolved_ctes, schema)?;
+            let output = pivot_output_columns(pivot, &input, None);
+            (!output.is_empty()).then(|| output.into_iter().map(|(post, _)| post).collect())
+        }
+        SourceRelation::Unpivot(unpivot) => {
+            let input = pivot_input_columns(&unpivot.this, resolved_ctes, schema)?;
+            let output = crate::resolver::unpivot_output_columns(unpivot, input, None);
+            (!output.is_empty()).then_some(output)
+        }
+        SourceRelation::Pivot(_) => None,
+    }
+}
+
+fn pivot_input_columns(
+    input: &Expression,
+    resolved_ctes: &HashMap<String, Vec<String>>,
+    schema: Option<&dyn Schema>,
+) -> Option<Vec<String>> {
+    match input {
+        Expression::Table(table) => {
+            let cte_columns = (table.schema.is_none() && table.catalog.is_none())
+                .then(|| resolved_ctes.get(&normalize_cte_name(&table.name)).cloned())
+                .flatten();
+            cte_columns.or_else(|| {
+                let fq_name = [&table.catalog, &table.schema]
+                    .into_iter()
+                    .flatten()
+                    .map(|part| part.name.as_str())
+                    .chain(std::iter::once(table.name.name.as_str()))
+                    .collect::<Vec<_>>()
+                    .join(".");
+                lookup_schema_columns(schema, &fq_name)
+            })
+        }
+        Expression::Paren(paren) => pivot_input_columns(&paren.this, resolved_ctes, schema),
+        _ => None,
+    }
+}
+
 /// Look up column names for a table from the schema.
 fn lookup_schema_columns(schema: Option<&dyn Schema>, fq_name: &str) -> Option<Vec<String>> {
     let schema = schema?;
@@ -802,6 +841,16 @@ struct SourceInfo {
     normalized: String,
     /// Fully-qualified table name for schema lookup (e.g., "db.schema.table").
     fq_name: String,
+    /// Relation shape that determines how this source's output columns are derived.
+    relation: SourceRelation,
+}
+
+/// PIVOT and UNPIVOT change their input's columns, so their output cannot be
+/// read from the CTE or table that happens to share the source name.
+enum SourceRelation {
+    Plain,
+    Pivot(Box<crate::expressions::Pivot>),
+    Unpivot(Box<crate::expressions::Unpivot>),
 }
 
 /// Extract source info (alias, normalized CTE name, fully-qualified name) from a
@@ -816,6 +865,7 @@ fn get_select_sources(select: &Select) -> Vec<SourceInfo> {
                 quoted: alias.quoted,
                 normalized: normalize_cte_name(alias),
                 fq_name: alias.name.clone(),
+                relation: SourceRelation::Plain,
             }
         }
 
@@ -825,6 +875,7 @@ fn get_select_sources(select: &Select) -> Vec<SourceInfo> {
                 quoted: false,
                 normalized: alias.to_lowercase(),
                 fq_name: alias.to_string(),
+                relation: SourceRelation::Plain,
             }
         }
 
@@ -850,6 +901,7 @@ fn get_select_sources(select: &Select) -> Vec<SourceInfo> {
                     quoted: t.name.quoted,
                     normalized,
                     fq_name,
+                    relation: SourceRelation::Plain,
                 })
             }
             Expression::Subquery(s) => {
@@ -862,6 +914,7 @@ fn get_select_sources(select: &Select) -> Vec<SourceInfo> {
                     quoted: alias_identifier.quoted,
                     normalized,
                     fq_name,
+                    relation: SourceRelation::Plain,
                 })
             }
             Expression::Unnest(u) => u.alias.as_ref().map(virtual_source_info),
@@ -887,6 +940,7 @@ fn get_select_sources(select: &Select) -> Vec<SourceInfo> {
                     quoted: false,
                     normalized: alias.to_lowercase(),
                     fq_name: alias,
+                    relation: SourceRelation::Pivot(pivot.clone()),
                 })
             }
             Expression::Unpivot(unpivot) => {
@@ -899,6 +953,7 @@ fn get_select_sources(select: &Select) -> Vec<SourceInfo> {
                     quoted: false,
                     normalized: alias.to_lowercase(),
                     fq_name: alias,
+                    relation: SourceRelation::Unpivot(unpivot.clone()),
                 })
             }
             Expression::Paren(p) => extract_source(&p.this),

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/crates/polyglot-sql/src/resolver.rs

@@ -387,29 +387,7 @@ impl<'a> Resolver<'a> {
 
     fn get_unpivot_output_columns(&self, unpivot: &crate::expressions::Unpivot) -> Vec<String> {
         let pre_columns = self.get_source_output_columns(&unpivot.this);
-        if pre_columns.is_empty() || pre_columns.iter().any(|column| column == "*") {
-            return Vec::new();
-        }
-
-        let input_columns: HashSet<String> = unpivot
-            .columns
-            .iter()
-            .flat_map(expression_column_names)
-            .map(|column| normalize_column_name(&column, self.dialect))
-            .collect();
-        let mut columns: Vec<String> = pre_columns
-            .into_iter()
-            .filter(|column| !input_columns.contains(&normalize_column_name(column, self.dialect)))
-            .collect();
-        columns.push(unpivot.name_column.name.clone());
-        columns.push(unpivot.value_column.name.clone());
-        columns.extend(
-            unpivot
-                .extra_value_columns
-                .iter()
-                .map(|column| column.name.clone()),
-        );
-        apply_alias_columns(columns, &unpivot.alias_columns)
+        unpivot_output_columns(unpivot, pre_columns, self.dialect)
     }
 
     fn get_source_output_columns(&self, source: &Expression) -> Vec<String> {
@@ -657,6 +635,38 @@ fn normalize_column_name(name: &str, dialect: Option<DialectType>) -> String {
     normalize_name(name, dialect, false, true)
 }
 
+/// UNPIVOT output: unconsumed input columns, then name and value columns.
+/// Returns no columns when the input columns are unknown.
+pub(crate) fn unpivot_output_columns(
+    unpivot: &crate::expressions::Unpivot,
+    pre_columns: Vec<String>,
+    dialect: Option<DialectType>,
+) -> Vec<String> {
+    if pre_columns.is_empty() || pre_columns.iter().any(|column| column == "*") {
+        return Vec::new();
+    }
+
+    let input_columns: HashSet<String> = unpivot
+        .columns
+        .iter()
+        .flat_map(expression_column_names)
+        .map(|column| normalize_column_name(&column, dialect))
+        .collect();
+    let mut columns: Vec<String> = pre_columns
+        .into_iter()
+        .filter(|column| !input_columns.contains(&normalize_column_name(column, dialect)))
+        .collect();
+    columns.push(unpivot.name_column.name.clone());
+    columns.push(unpivot.value_column.name.clone());
+    columns.extend(
+        unpivot
+            .extra_value_columns
+            .iter()
+            .map(|column| column.name.clone()),
+    );
+    apply_alias_columns(columns, &unpivot.alias_columns)
+}
+
 fn apply_alias_columns(mut columns: Vec<String>, alias_columns: &[Identifier]) -> Vec<String> {
     for (idx, alias) in alias_columns.iter().enumerate() {
         if let Some(column) = columns.get_mut(idx) {

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/crates/polyglot-sql/tests/query_analysis.rs

@@ -3499,3 +3499,119 @@ fn analyze_query_resolves_snowflake_dynamic_pivot_over_cte_without_recursion() {
 
     assert!(!analysis.projections.is_empty());
 }
+
+struct ReshapedStarCase {
+    name: &'static str,
+    sql: &'static str,
+    with_schema: bool,
+    expected_columns: &'static [&'static str],
+    expected_upstream: Option<&'static [&'static [(&'static str, &'static str)]]>,
+}
+
+const PIVOTED_UPSTREAM: &[&[(&str, &str)]] = &[
+    &[("staged_orders", "customer_id")],
+    &[("staged_orders", "amount")],
+    &[("staged_orders", "amount")],
+];
+
+#[test]
+fn star_over_pivot_and_unpivot_reports_reshaped_columns_in_every_mode() {
+    let schema: ValidationSchema = serde_json::from_value(json!({
+        "tables": [
+            {"name": "staged_orders", "columns": [
+                {"name": "customer_id", "type": "INT"},
+                {"name": "category", "type": "VARCHAR"},
+                {"name": "amount", "type": "INT"}
+            ]},
+            {"name": "wide_orders", "columns": [
+                {"name": "customer_id", "type": "INT"},
+                {"name": "books", "type": "INT"},
+                {"name": "games", "type": "INT"}
+            ]}
+        ]
+    }))
+    .unwrap();
+    let ctes = "WITH pivot_input AS (SELECT customer_id, category, amount FROM staged_orders), \
+                wide_input AS (SELECT customer_id, books, games FROM wide_orders) ";
+    let cases = [
+        ReshapedStarCase {
+            name: "pivot over cte",
+            sql: "SELECT * FROM pivot_input PIVOT (MAX(amount) FOR category IN ('books', 'games'))",
+            with_schema: true,
+            expected_columns: &["customer_id", "books", "games"],
+            expected_upstream: Some(PIVOTED_UPSTREAM),
+        },
+        ReshapedStarCase {
+            name: "pivot over cte without schema",
+            sql: "SELECT * FROM pivot_input PIVOT (MAX(amount) FOR category IN ('books', 'games'))",
+            with_schema: false,
+            expected_columns: &["customer_id", "books", "games"],
+            expected_upstream: Some(PIVOTED_UPSTREAM),
+        },
+        ReshapedStarCase {
+            name: "pivot over table",
+            sql:
+                "SELECT * FROM staged_orders PIVOT (MAX(amount) FOR category IN ('books', 'games'))",
+            with_schema: true,
+            expected_columns: &["customer_id", "books", "games"],
+            expected_upstream: Some(PIVOTED_UPSTREAM),
+        },
+        ReshapedStarCase {
+            name: "qualified star over aliased pivot",
+            sql: "SELECT pv.* FROM pivot_input \
+                  PIVOT (MAX(amount) FOR category IN ('books', 'games')) AS pv",
+            with_schema: true,
+            expected_columns: &["customer_id", "books", "games"],
+            expected_upstream: Some(PIVOTED_UPSTREAM),
+        },
+        ReshapedStarCase {
+            name: "unpivot over cte",
+            sql: "SELECT * FROM wide_input UNPIVOT (amount FOR category IN (books, games))",
+            with_schema: true,
+            expected_columns: &["customer_id", "category", "amount"],
+            expected_upstream: None,
+        },
+    ];
+    for case in cases {
+        let sql = format!("{ctes}{}", case.sql);
+        let options = AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            schema: case.with_schema.then(|| schema.clone()),
+            ..Default::default()
+        };
+        for (mode, analysis) in [
+            ("default", analyze_query(&sql, options.clone()).unwrap()),
+            (
+                "project",
+                analyze_query_for_project_projections(&sql, options.clone()).unwrap(),
+            ),
+        ] {
+            let columns: Vec<_> = analysis
+                .projections
+                .iter()
+                .map(|projection| projection.name.as_deref().unwrap_or_default())
+                .collect();
+            assert_eq!(columns, case.expected_columns, "{} ({mode})", case.name);
+            let Some(expected_upstream) = case.expected_upstream else {
+                continue;
+            };
+            let upstream: Vec<Vec<_>> = analysis
+                .projections
+                .iter()
+                .map(|projection| {
+                    projection
+                        .upstream
+                        .iter()
+                        .map(|column| {
+                            (
+                                column.table.as_deref().unwrap_or_default(),
+                                column.column.as_str(),
+                            )
+                        })
+                        .collect()
+                })
+                .collect();
+            assert_eq!(upstream, expected_upstream, "{} ({mode})", case.name);
+        }
+    }
+}

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/crates/polyglot-sql-function-catalogs/README.md

@@ -25,7 +25,7 @@ With `polyglot-sql` compile-time wiring (recommended):
 
 ```toml
 [dependencies]
-polyglot-sql = { version = "0.12.2", features = ["function-catalog-clickhouse"] }
+polyglot-sql = { version = "0.12.3", features = ["function-catalog-clickhouse"] }
 ```
 
 Then run schema validation with type checks:

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/crates/polyglot-sql-python/Cargo.toml

@@ -19,6 +19,7 @@ default = []
 function-catalog-clickhouse = ["polyglot-sql/function-catalog-clickhouse"]
 function-catalog-duckdb = ["polyglot-sql/function-catalog-duckdb"]
 function-catalog-all-dialects = ["polyglot-sql/function-catalog-all-dialects"]
+abi3 = ["pyo3/abi3-py312"]
 
 [dependencies]
 polyglot-sql = { path = "../polyglot-sql" }

{polyglot_sql_chio-0.12.2 → polyglot_sql_chio-0.12.3}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "Rust-powered SQL transpiler for more than 30 SQL dialects. Parse, generate, transpile, format, and validate SQL."
 readme = "README.md"
 license = { text = "MIT" }
-requires-python = ">=3.9"
+requires-python = ">=3.12"
 keywords = ["sql", "transpiler", "parser", "dialect", "database"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -17,9 +17,6 @@ classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Topic :: Database",