Fix #247, #248, #249, version bump to 0.5.8

Author: tobilg

CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project are documented in this file.
 
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 
+## [0.5.8] - 2026-06-22
+
+### Added
+- Regression coverage for nested set-operation derived table lineage, scalar
+  subqueries inside expression wrappers, same-select alias references,
+  pivot/unpivot alias columns, and semi/anti join source inference across Rust
+  core, C FFI, WASM/TypeScript, Python, and Go.
+
+### Fixed
+- Lineage now registers aliased query-like derived relations such as nested
+  `UNION` expressions in `FROM`, so output columns trace back to each physical
+  source table instead of stopping at the derived relation.
+- Scalar subqueries wrapped in expressions such as `CASE`, `COALESCE`, `CAST`,
+  `BETWEEN`, `IN`, `ANY`, `ALL`, and `EXISTS` now contribute their source-column
+  lineage.
+- Same-select alias references now resolve through earlier projection
+  expressions before column qualification, avoiding unresolved or incorrect
+  physical-column attribution.
+- Pivot and unpivot lineage now preserves alias column lists and maps renamed or
+  generated outputs back to implicit source columns and aggregate input columns.
+- Star and source inference now ignores semi/anti join right-hand inputs,
+  preventing non-output join sources from making schema-less star lineage
+  ambiguous.
+
 ## [0.5.7] - 2026-06-19
 
 ### Added

Cargo.lock

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

Cargo.toml

@@ -728,6 +728,31 @@ fn test_lineage_schema_less_cte_star_passthrough() {
     );
 }
 
+#[test]
+fn test_lineage_nested_set_operation_inside_derived_table() {
+    let column = c("v");
+    let sql = c(
+        "SELECT v FROM ((SELECT v FROM t1 UNION ALL SELECT v FROM t2) UNION ALL SELECT v FROM t3) u",
+    );
+    let dialect = c("duckdb");
+    let (status, data, error) = consume_result(polyglot_lineage(
+        column.as_ptr(),
+        sql.as_ptr(),
+        dialect.as_ptr(),
+    ));
+    assert_eq!(status, 0, "error={error:?}");
+    let node: Value = serde_json::from_str(&data.expect("missing lineage")).expect("invalid json");
+
+    let mut names = Vec::new();
+    collect_lineage_names(&node, &mut names);
+    assert!(
+        names.iter().any(|name| name == "t1.v")
+            && names.iter().any(|name| name == "t2.v")
+            && names.iter().any(|name| name == "t3.v"),
+        "expected set operation source columns in lineage names, got {names:?}"
+    );
+}
+
 #[test]
 fn test_lineage_recursive_cte_terminates() {
     let column = c("n");
@@ -889,6 +914,42 @@ fn test_analyze_query_cte_facts_and_star_projections() {
     );
 }
 
+#[test]
+fn test_analyze_query_pivot_alias_columns() {
+    let sql = c(
+        "SELECT region2, p1 FROM (SELECT region, q, amt FROM sales) PIVOT(SUM(amt) FOR q IN ('Q1')) AS p(region2, p1)",
+    );
+    let options = c(r#"{"dialect":"duckdb"}"#);
+    let (status, data, error) =
+        consume_result(polyglot_analyze_query(sql.as_ptr(), options.as_ptr()));
+    assert_eq!(status, 0, "error={error:?}");
+    let analysis: Value =
+        serde_json::from_str(&data.expect("missing analyze_query payload")).expect("invalid json");
+
+    let projections = analysis["projections"]
+        .as_array()
+        .expect("projections array");
+    let region = projections
+        .iter()
+        .find(|projection| projection["name"] == "region2")
+        .expect("region2 projection");
+    assert!(region["upstream"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|reference| { reference["table"] == "sales" && reference["column"] == "region" }));
+
+    let pivot_value = projections
+        .iter()
+        .find(|projection| projection["name"] == "p1")
+        .expect("p1 projection");
+    assert!(pivot_value["upstream"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|reference| reference["table"] == "sales" && reference["column"] == "amt"));
+}
+
 #[test]
 fn test_analyze_query_invalid_options_json() {
     let sql = c("SELECT 1");

crates/polyglot-sql-ffi/tests/ffi_tests.rs

@@ -46,6 +46,19 @@ def test_lineage_window_over_columns():
     assert "events.ts" in names
 
 
+def test_lineage_nested_set_operation_inside_derived_table():
+    sql = (
+        "SELECT v FROM ((SELECT v FROM t1 UNION ALL SELECT v FROM t2) "
+        "UNION ALL SELECT v FROM t3) u"
+    )
+    result = polyglot_sql.lineage("v", sql, dialect="duckdb")
+
+    names = collect_names(result)
+    assert "t1.v" in names
+    assert "t2.v" in names
+    assert "t3.v" in names
+
+
 def test_source_tables_returns_orders():
     sql = "SELECT o.total FROM orders o JOIN users u ON o.user_id = u.id"
     tables = polyglot_sql.source_tables("total", sql, dialect="postgres")

crates/polyglot-sql-python/tests/test_lineage.py

@@ -122,6 +122,32 @@ def test_analyze_query_reports_cte_facts_and_star_projections():
     assert result["starProjections"][0]["expandedColumns"] == ["id", "amount"]
 
 
+def test_analyze_query_resolves_pivot_alias_columns():
+    result = polyglot_sql.analyze_query(
+        "SELECT region2, p1 FROM (SELECT region, q, amt FROM sales) "
+        "PIVOT(SUM(amt) FOR q IN ('Q1')) AS p(region2, p1)",
+        {"dialect": "duckdb"},
+    )
+
+    region = next(
+        projection
+        for projection in result["projections"]
+        if projection["name"] == "region2"
+    )
+    assert any(
+        reference["table"] == "sales" and reference["column"] == "region"
+        for reference in region["upstream"]
+    )
+
+    pivot_value = next(
+        projection for projection in result["projections"] if projection["name"] == "p1"
+    )
+    assert any(
+        reference["table"] == "sales" and reference["column"] == "amt"
+        for reference in pivot_value["upstream"]
+    )
+
+
 def test_analyze_query_unknown_dialect_raises_value_error():
     with pytest.raises(ValueError):
         polyglot_sql.analyze_query("SELECT 1", dialect="not_a_dialect")

crates/polyglot-sql-python/tests/test_query_analysis.py

@@ -3290,6 +3290,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_lineage_nested_set_operation_inside_derived_table() {
+        let result = lineage_sql(
+            "SELECT v FROM ((SELECT v FROM t1 UNION ALL SELECT v FROM t2) UNION ALL SELECT v FROM t3) u",
+            "v",
+            "duckdb",
+            false,
+        );
+        assert!(result.contains("\"success\":true"), "Result: {}", result);
+        let result: serde_json::Value = serde_json::from_str(&result).expect("valid wrapper json");
+        let lineage = result["lineage"].as_object().expect("lineage object");
+        let names = collect_lineage_names(&serde_json::Value::Object(lineage.clone()));
+        assert!(
+            names.iter().any(|name| name == "t1.v")
+                && names.iter().any(|name| name == "t2.v")
+                && names.iter().any(|name| name == "t3.v"),
+            "expected set operation source columns in lineage names, got {names:?}"
+        );
+    }
+
     #[test]
     fn test_lineage_bigquery_unnest_virtual_source_metadata() {
         let result = lineage_sql(
@@ -3536,6 +3556,34 @@ mod tests {
             parsed["analysis"]["starProjections"][0]["expandedColumns"][1],
             "amount"
         );
+
+        let result = analyze_query(
+            "SELECT region2, p1 FROM (SELECT region, q, amt FROM sales) PIVOT(SUM(amt) FOR q IN ('Q1')) AS p(region2, p1)",
+            r#"{"dialect":"duckdb"}"#,
+        );
+        let parsed: serde_json::Value = serde_json::from_str(&result).expect("valid json");
+        assert_eq!(parsed["success"], true);
+        let projections = parsed["analysis"]["projections"]
+            .as_array()
+            .expect("projections array");
+        let region = projections
+            .iter()
+            .find(|projection| projection["name"] == "region2")
+            .expect("region2 projection");
+        assert!(region["upstream"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|reference| { reference["table"] == "sales" && reference["column"] == "region" }));
+        let pivot_value = projections
+            .iter()
+            .find(|projection| projection["name"] == "p1")
+            .expect("p1 projection");
+        assert!(pivot_value["upstream"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|reference| reference["table"] == "sales" && reference["column"] == "amt"));
     }
 
     #[test]

crates/polyglot-sql-wasm/src/lib.rs

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

crates/polyglot-sql/Cargo.toml

@@ -4118,6 +4118,9 @@ pub struct Pivot {
     /// Optional alias
     #[serde(default)]
     pub alias: Option<Identifier>,
+    /// Optional output column aliases from `PIVOT(...) AS alias(col1, col2, ...)`
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub alias_columns: Vec<Identifier>,
     /// Include/exclude nulls (for UNPIVOT)
     #[serde(default)]
     pub include_nulls: Option<bool>,
@@ -4138,6 +4141,9 @@ pub struct Unpivot {
     pub name_column: Identifier,
     pub columns: Vec<Expression>,
     pub alias: Option<Identifier>,
+    /// Optional output column aliases from `UNPIVOT(...) AS alias(col1, col2, ...)`
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub alias_columns: Vec<Identifier>,
     /// Whether the value_column was parenthesized in the original SQL
     #[serde(default)]
     pub value_column_parenthesized: bool,

crates/polyglot-sql/src/expressions.rs

@@ -23391,6 +23391,7 @@ impl Generator {
             self.write_keyword("AS");
             self.write_space();
             self.generate_identifier(alias)?;
+            self.generate_alias_column_list(&pivot.alias_columns)?;
         }
 
         Ok(())
@@ -23442,10 +23443,27 @@ impl Generator {
             self.write_keyword("AS");
             self.write_space();
             self.generate_identifier(alias)?;
+            self.generate_alias_column_list(&unpivot.alias_columns)?;
         }
         Ok(())
     }
 
+    fn generate_alias_column_list(&mut self, columns: &[Identifier]) -> Result<()> {
+        if columns.is_empty() {
+            return Ok(());
+        }
+
+        self.write("(");
+        for (i, column) in columns.iter().enumerate() {
+            if i > 0 {
+                self.write(", ");
+            }
+            self.generate_identifier(column)?;
+        }
+        self.write(")");
+        Ok(())
+    }
+
     fn generate_values(&mut self, values: &Values) -> Result<()> {
         self.write_keyword("VALUES");
         for (i, row) in values.expressions.iter().enumerate() {