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

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

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

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

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

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

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

{polyglot_sql-0.5.9 → 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.9", 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.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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();

{polyglot_sql-0.5.9 → polyglot_sql-0.5.10}/crates/polyglot-sql/tests/query_analysis.rs

@@ -736,6 +736,118 @@ fn analyze_query_resolves_unnest_virtual_output_aliases_with_schema() {
     }
 }
 
+#[test]
+fn analyze_query_tolerates_partial_schema_for_unknown_columns() {
+    let analysis = analyze_query(
+        "SELECT order_id, amount FROM t",
+        AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            schema: Some(single_column_schema(&["t"], "amount")),
+        },
+    )
+    .unwrap();
+
+    assert_eq!(analysis.projections.len(), 2);
+    assert_eq!(analysis.projections[0].name.as_deref(), Some("order_id"));
+    assert_eq!(analysis.projections[1].name.as_deref(), Some("amount"));
+
+    let order_id = &analysis.projections[0].upstream;
+    assert!(
+        order_id.iter().any(|reference| {
+            reference.column == "order_id"
+                && reference.confidence == ReferenceConfidence::Resolved
+                && reference.source_name.as_deref() == Some("t")
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected best-effort order_id reference, got {order_id:?}"
+    );
+
+    let amount = &analysis.projections[1].upstream;
+    assert!(
+        amount.iter().any(|reference| {
+            reference.column == "amount"
+                && reference.confidence == ReferenceConfidence::Resolved
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected schema-backed amount reference, got {amount:?}"
+    );
+}
+
+#[test]
+fn analyze_query_tolerates_partial_schema_for_qualified_unknown_columns() {
+    let analysis = analyze_query(
+        "SELECT t.order_id, t.amount FROM t",
+        AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            schema: Some(single_column_schema(&["t"], "amount")),
+        },
+    )
+    .unwrap();
+
+    assert!(
+        analysis.projections[0].upstream.iter().any(|reference| {
+            reference.column == "order_id"
+                && reference.confidence == ReferenceConfidence::Resolved
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected qualified unknown column to stay as best-effort t.order_id, got {:?}",
+        analysis.projections[0].upstream
+    );
+    assert!(
+        analysis.projections[1].upstream.iter().any(|reference| {
+            reference.column == "amount" && reference.table.as_deref() == Some("t")
+        }),
+        "expected known t.amount to resolve, got {:?}",
+        analysis.projections[1].upstream
+    );
+}
+
+#[test]
+fn analyze_query_tolerates_partial_schema_for_join_conditions() {
+    let schema: ValidationSchema = serde_json::from_value(json!({
+        "tables": [
+            {
+                "name": "t",
+                "columns": [{"name": "order_id", "type": "INT"}]
+            },
+            {
+                "name": "u",
+                "columns": [{"name": "amount", "type": "INT"}]
+            }
+        ]
+    }))
+    .unwrap();
+
+    let analysis = analyze_query(
+        "SELECT a.order_id, b.amount FROM t a JOIN u b ON a.id = b.id",
+        AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            schema: Some(schema),
+        },
+    )
+    .unwrap();
+
+    assert_eq!(analysis.projections.len(), 2);
+    assert!(
+        analysis.projections[0].upstream.iter().any(|reference| {
+            reference.column == "order_id"
+                && reference.source_alias.as_deref() == Some("a")
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected a.order_id to resolve, got {:?}",
+        analysis.projections[0].upstream
+    );
+    assert!(
+        analysis.projections[1].upstream.iter().any(|reference| {
+            reference.column == "amount"
+                && reference.source_alias.as_deref() == Some("b")
+                && reference.table.as_deref() == Some("u")
+        }),
+        "expected b.amount to resolve, got {:?}",
+        analysis.projections[1].upstream
+    );
+}
+
 #[test]
 fn analyze_query_resolves_same_select_alias_reference() {
     let analysis = analyze_query(

{polyglot_sql-0.5.9 → polyglot_sql-0.5.10}/crates/polyglot-sql-python/tests/test_lineage.py

@@ -113,6 +113,23 @@ def test_lineage_with_schema_resolves_ambiguous_column():
     assert any(name == "u.id" for name in names), f"expected u.id in lineage tree, got: {names}"
 
 
+def test_lineage_with_schema_tolerates_partial_schema():
+    schema = {
+        "tables": [
+            {
+                "name": "t",
+                "columns": [{"name": "amount", "type": "INT"}],
+            }
+        ]
+    }
+    result = polyglot_sql.lineage_with_schema(
+        "amount", "SELECT order_id, amount FROM t", schema, dialect="duckdb"
+    )
+
+    names = collect_names(result)
+    assert "t.amount" in names
+
+
 def test_bigquery_unnest_lineage_marks_virtual_source():
     sql = """
 SELECT date_val AS week_start

{polyglot_sql-0.5.9 → polyglot_sql-0.5.10}/crates/polyglot-sql-python/tests/test_query_analysis.py

@@ -35,6 +35,36 @@ def test_analyze_query_accepts_schema_options():
     assert result["projections"][0]["castType"] == "TEXT"
 
 
+def test_analyze_query_tolerates_partial_schema():
+    schema = {
+        "tables": [
+            {
+                "name": "t",
+                "columns": [{"name": "amount", "type": "INT"}],
+            }
+        ]
+    }
+    result = polyglot_sql.analyze_query(
+        "SELECT order_id, amount FROM t",
+        {"schema": schema, "dialect": "duckdb"},
+    )
+
+    assert [projection["name"] for projection in result["projections"]] == [
+        "order_id",
+        "amount",
+    ]
+    assert any(
+        reference["column"] == "order_id"
+        and reference["table"] == "t"
+        and reference["confidence"] == "resolved"
+        for reference in result["projections"][0]["upstream"]
+    )
+    assert any(
+        reference["column"] == "amount" and reference["table"] == "t"
+        for reference in result["projections"][1]["upstream"]
+    )
+
+
 def test_analyze_query_reports_transform_function_arguments():
     schema = {
         "tables": [