polyglot-sql 0.5.8__tar.gz → 0.5.10__tar.gz

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.5.8"
+version = "0.5.10"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.5.8"
+version = "0.5.10"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.5.8"
+version = "0.5.10"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.5.8"
+version = "0.5.10"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.5.8"
+version = "0.5.10"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/Cargo.toml

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

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.8
+Version: 0.5.10
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/crates/polyglot-sql/Cargo.toml

@@ -106,7 +106,7 @@ 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.5.8", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.10", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -1068,6 +1068,11 @@ impl DialectImpl for DuckDBDialect {
             // WithinGroup: PERCENTILE_CONT/DISC WITHIN GROUP (ORDER BY ...) -> QUANTILE_CONT/DISC(col, quantile ORDER BY ...)
             Expression::WithinGroup(wg) => {
                 match &wg.this {
+                    Expression::ListAgg(listagg) => {
+                        let mut listagg = listagg.clone();
+                        listagg.order_by = Some(wg.order_by.clone());
+                        Ok(Expression::ListAgg(listagg))
+                    }
                     Expression::PercentileCont(p) => {
                         let column = wg
                             .order_by
@@ -7496,7 +7501,11 @@ mod tests {
     use crate::dialects::Dialect;
 
     fn transpile_to_duckdb(sql: &str) -> String {
-        let dialect = Dialect::get(DialectType::Generic);
+        transpile_to_duckdb_from(sql, DialectType::Generic)
+    }
+
+    fn transpile_to_duckdb_from(sql: &str, read: DialectType) -> String {
+        let dialect = Dialect::get(read);
         let result = dialect
             .transpile(sql, DialectType::DuckDB)
             .expect("Transpile failed");
@@ -7550,6 +7559,36 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_ordered_string_agg_uses_duckdb_listagg_order_syntax() {
+        let result = transpile_to_duckdb_from(
+            "SELECT string_agg(nm, ',' ORDER BY id) AS v FROM t",
+            DialectType::PostgreSQL,
+        );
+        assert_eq!(result, "SELECT LISTAGG(nm, ',' ORDER BY id) AS v FROM t");
+    }
+
+    #[test]
+    fn test_ordered_listagg_uses_duckdb_order_syntax() {
+        let result = transpile_to_duckdb_from(
+            "SELECT LISTAGG(col, '|SEPARATOR|') WITHIN GROUP (ORDER BY col2) FROM t",
+            DialectType::Snowflake,
+        );
+        assert_eq!(
+            result,
+            "SELECT LISTAGG(col, '|SEPARATOR|' ORDER BY col2) FROM t"
+        );
+    }
+
+    #[test]
+    fn test_ordered_group_concat_uses_duckdb_listagg_order_syntax() {
+        let result = transpile_to_duckdb_from(
+            "SELECT GROUP_CONCAT(nm ORDER BY id SEPARATOR ',') AS v FROM t",
+            DialectType::MySQL,
+        );
+        assert_eq!(result, "SELECT LISTAGG(nm, ',' ORDER BY id) AS v FROM t");
+    }
+
     #[test]
     fn test_date_format_to_strftime() {
         let result = transpile_to_duckdb("SELECT DATE_FORMAT(d, '%Y-%m-%d')");

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/crates/polyglot-sql/src/generator.rs

@@ -20369,6 +20369,7 @@ impl Generator {
 
     fn generate_listagg(&mut self, f: &ListAggFunc) -> Result<()> {
         use crate::dialects::DialectType;
+        let order_inside_args = matches!(self.config.dialect, Some(DialectType::DuckDB));
         self.write_keyword("LISTAGG");
         self.write("(");
         if f.distinct {
@@ -20408,20 +20409,35 @@ impl Generator {
                 }
             }
         }
+        if order_inside_args {
+            if let Some(ref order_by) = f.order_by {
+                self.write_space();
+                self.write_keyword("ORDER BY");
+                self.write_space();
+                for (i, ord) in order_by.iter().enumerate() {
+                    if i > 0 {
+                        self.write(", ");
+                    }
+                    self.generate_ordered(ord)?;
+                }
+            }
+        }
         self.write(")");
-        if let Some(ref order_by) = f.order_by {
-            self.write_space();
-            self.write_keyword("WITHIN GROUP");
-            self.write(" (");
-            self.write_keyword("ORDER BY");
-            self.write_space();
-            for (i, ord) in order_by.iter().enumerate() {
-                if i > 0 {
-                    self.write(", ");
+        if !order_inside_args {
+            if let Some(ref order_by) = f.order_by {
+                self.write_space();
+                self.write_keyword("WITHIN GROUP");
+                self.write(" (");
+                self.write_keyword("ORDER BY");
+                self.write_space();
+                for (i, ord) in order_by.iter().enumerate() {
+                    if i > 0 {
+                        self.write(", ");
+                    }
+                    self.generate_ordered(ord)?;
                 }
-                self.generate_ordered(ord)?;
+                self.write(")");
             }
-            self.write(")");
         }
         if let Some(ref filter) = f.filter {
             self.write_space();

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/crates/polyglot-sql/src/lineage.rs

@@ -194,9 +194,11 @@ pub fn lineage_with_schema(
     let normalized_expression = lineage_normalized_expression(sql);
     let mut qualified_expression = if let Some(schema) = schema {
         let options = if let Some(dialect_type) = dialect.or_else(|| schema.dialect()) {
-            QualifyColumnsOptions::new().with_dialect(dialect_type)
-        } else {
             QualifyColumnsOptions::new()
+                .with_dialect(dialect_type)
+                .with_allow_partial(true)
+        } else {
+            QualifyColumnsOptions::new().with_allow_partial(true)
         };
 
         qualify_columns(normalized_expression.clone(), schema, &options).map_err(|e| {
@@ -3705,6 +3707,88 @@ mod tests {
         assert_eq!(expr_with.inferred_type(), Some(&DataType::Text));
     }
 
+    #[test]
+    fn test_lineage_with_schema_tolerates_partial_schema_for_known_column() {
+        let expr = parse_dialect("SELECT order_id, amount FROM t", DialectType::DuckDB);
+        let mut schema = MappingSchema::with_dialect(DialectType::DuckDB);
+        schema
+            .add_table(
+                "t",
+                &[("amount".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+
+        let node = lineage_with_schema(
+            "amount",
+            &expr,
+            Some(&schema),
+            Some(DialectType::DuckDB),
+            false,
+        )
+        .expect("lineage_with_schema should tolerate unrelated unknown columns");
+
+        assert_lineage_contains(&node, "t.amount");
+    }
+
+    #[test]
+    fn test_lineage_with_schema_tolerates_partial_schema_for_unknown_column() {
+        let expr = parse_dialect("SELECT order_id, amount FROM t", DialectType::DuckDB);
+        let mut schema = MappingSchema::with_dialect(DialectType::DuckDB);
+        schema
+            .add_table(
+                "t",
+                &[("amount".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+
+        let node = lineage_with_schema(
+            "order_id",
+            &expr,
+            Some(&schema),
+            Some(DialectType::DuckDB),
+            false,
+        )
+        .expect("lineage_with_schema should keep unknown selected columns");
+
+        assert_lineage_contains(&node, "t.order_id");
+    }
+
+    #[test]
+    fn test_lineage_with_schema_tolerates_partial_schema_for_join_conditions() {
+        let expr = parse_dialect(
+            "SELECT a.order_id, b.amount FROM t a JOIN u b ON a.id = b.id",
+            DialectType::DuckDB,
+        );
+        let mut schema = MappingSchema::with_dialect(DialectType::DuckDB);
+        schema
+            .add_table(
+                "t",
+                &[("order_id".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+        schema
+            .add_table(
+                "u",
+                &[("amount".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+
+        let node = lineage_with_schema(
+            "amount",
+            &expr,
+            Some(&schema),
+            Some(DialectType::DuckDB),
+            false,
+        )
+        .expect("lineage_with_schema should tolerate unknown join keys");
+
+        assert_lineage_contains(&node, "b.amount");
+    }
+
     #[test]
     fn test_lineage_with_schema_correlated_scalar_subquery() {
         let query = "SELECT id, (SELECT AVG(val) FROM t2 WHERE t2.id = t1.id) AS avg_val FROM t1";

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/crates/polyglot-sql/src/query_analysis.rs

@@ -187,7 +187,9 @@ pub fn analyze_query(sql: &str, options: AnalyzeQueryOptions) -> Result<QueryAna
     let star_projections = star_projection_facts(&original_expression, mapping_schema.as_ref());
 
     if let Some(schema) = mapping_schema.as_ref() {
-        let qualify_options = QualifyColumnsOptions::new().with_dialect(options.dialect);
+        let qualify_options = QualifyColumnsOptions::new()
+            .with_dialect(options.dialect)
+            .with_allow_partial(true);
         expression = qualify_columns(expression, schema, &qualify_options)
             .map_err(|e| Error::internal(format!("query analysis qualification failed: {e}")))?;
     }

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/crates/polyglot-sql/src/resolver.rs

@@ -173,7 +173,14 @@ impl<'a> Resolver<'a> {
 
     /// Extract column names from a source expression
     fn extract_columns_from_source(&self, source_info: &SourceInfo) -> ResolverResult<Vec<String>> {
-        let columns = match &source_info.expression {
+        self.get_source_columns_for_expression(&source_info.expression)
+    }
+
+    fn get_source_columns_for_expression(
+        &self,
+        expression: &Expression,
+    ) -> ResolverResult<Vec<String>> {
+        let columns = match expression {
             Expression::Table(table) => {
                 // For tables, try to get columns from schema.
                 // Build the fully qualified name (catalog.schema.table) to
@@ -211,6 +218,17 @@ impl<'a> Resolver<'a> {
             }
             Expression::Pivot(pivot) => self.get_pivot_output_columns(pivot),
             Expression::Unpivot(unpivot) => self.get_unpivot_output_columns(unpivot),
+            Expression::Alias(alias) if matches!(&alias.this, Expression::Unnest(_)) => {
+                alias_output_columns(alias)
+            }
+            Expression::Alias(alias) => {
+                let columns = self.get_source_columns_for_expression(&alias.this)?;
+                apply_alias_columns(columns, &alias.column_aliases)
+            }
+            Expression::Unnest(unnest) => unnest_output_columns(unnest),
+            Expression::Lateral(lateral) => lateral_output_columns(lateral),
+            Expression::LateralView(lateral_view) => lateral_view_output_columns(lateral_view),
+            Expression::Paren(paren) => self.get_source_columns_for_expression(&paren.this)?,
             _ => Vec::new(),
         };
 
@@ -228,6 +246,11 @@ impl<'a> Resolver<'a> {
             Expression::Intersect(intersect) => self.get_named_selects(&intersect.left),
             Expression::Except(except) => self.get_named_selects(&except.left),
             Expression::Subquery(subquery) => self.get_named_selects(&subquery.this),
+            Expression::Alias(alias) => {
+                let columns = self.get_named_selects(&alias.this);
+                apply_alias_columns(columns, &alias.column_aliases)
+            }
+            Expression::Paren(paren) => self.get_named_selects(&paren.this),
             _ => Vec::new(),
         }
     }
@@ -351,6 +374,16 @@ impl<'a> Resolver<'a> {
             Expression::Union(_) | Expression::Intersect(_) | Expression::Except(_) => self
                 .get_source_columns_from_set_op(source)
                 .unwrap_or_default(),
+            Expression::Alias(alias) if matches!(&alias.this, Expression::Unnest(_)) => {
+                alias_output_columns(alias)
+            }
+            Expression::Alias(alias) => {
+                let columns = self.get_source_output_columns(&alias.this);
+                apply_alias_columns(columns, &alias.column_aliases)
+            }
+            Expression::Unnest(unnest) => unnest_output_columns(unnest),
+            Expression::Lateral(lateral) => lateral_output_columns(lateral),
+            Expression::LateralView(lateral_view) => lateral_view_output_columns(lateral_view),
             Expression::Cte(cte) => {
                 if cte.columns.is_empty() {
                     self.get_named_selects(&cte.this)
@@ -383,6 +416,11 @@ impl<'a> Resolver<'a> {
                     Ok(self.get_named_selects(&subquery.this))
                 }
             }
+            Expression::Alias(alias) => {
+                let columns = self.get_source_columns_from_set_op(&alias.this)?;
+                Ok(apply_alias_columns(columns, &alias.column_aliases))
+            }
+            Expression::Paren(paren) => self.get_source_columns_from_set_op(&paren.this),
             Expression::Union(union) => {
                 // Standard UNION: columns come from the left side
                 self.get_source_columns_from_set_op(&union.left)
@@ -540,6 +578,59 @@ fn apply_alias_columns(mut columns: Vec<String>, alias_columns: &[Identifier]) -
     columns
 }
 
+fn unnest_output_columns(unnest: &crate::expressions::UnnestFunc) -> Vec<String> {
+    unnest
+        .alias
+        .iter()
+        .map(|alias| alias.name.clone())
+        .chain(unnest.offset_alias.iter().map(|alias| alias.name.clone()))
+        .collect()
+}
+
+fn alias_output_columns(alias: &crate::expressions::Alias) -> Vec<String> {
+    if alias.column_aliases.is_empty() {
+        vec![alias.alias.name.clone()]
+    } else {
+        alias
+            .column_aliases
+            .iter()
+            .map(|column| column.name.clone())
+            .collect()
+    }
+}
+
+fn lateral_output_columns(lateral: &crate::expressions::Lateral) -> Vec<String> {
+    if lateral.column_aliases.is_empty() {
+        default_virtual_output_columns(&lateral.this)
+    } else {
+        lateral.column_aliases.clone()
+    }
+}
+
+fn lateral_view_output_columns(lateral_view: &crate::expressions::LateralView) -> Vec<String> {
+    lateral_view
+        .column_aliases
+        .iter()
+        .map(|column| column.name.clone())
+        .collect()
+}
+
+fn default_virtual_output_columns(expression: &Expression) -> Vec<String> {
+    match expression {
+        Expression::Unnest(unnest) => unnest_output_columns(unnest),
+        Expression::Alias(alias) if matches!(&alias.this, Expression::Unnest(_)) => {
+            alias_output_columns(alias)
+        }
+        Expression::Function(function) if function.name.eq_ignore_ascii_case("FLATTEN") => {
+            ["seq", "key", "path", "index", "value", "this"]
+                .into_iter()
+                .map(String::from)
+                .collect()
+        }
+        _ => Vec::new(),
+    }
+}
+
 fn pivot_excluded_source_columns(
     pivot: &crate::expressions::Pivot,
     dialect: Option<DialectType>,

{polyglot_sql-0.5.8 → polyglot_sql-0.5.10}/crates/polyglot-sql/src/validation/tests.rs

@@ -217,6 +217,29 @@ fn test_validate_with_schema_unknown_column() {
     );
 }
 
+#[test]
+fn test_validate_with_schema_partial_schema_stays_strict() {
+    let mut schema = base_schema();
+    let users = schema
+        .tables
+        .iter_mut()
+        .find(|table| table.name == "users")
+        .expect("users table");
+    users.columns.retain(|column| column.name == "id");
+
+    let opts = SchemaValidationOptions::default();
+    let result = validate_with_schema(
+        "SELECT id, name FROM users",
+        DialectType::Generic,
+        &schema,
+        &opts,
+    );
+    assert!(!result.valid);
+    assert!(result.errors.iter().any(|error| {
+        error.code == validation_codes::E_UNKNOWN_COLUMN && error.message.contains("name")
+    }));
+}
+
 #[test]
 fn test_validate_with_schema_function_catalog_unknown_function() {
     let schema = base_schema();