Register the aliases of table functions and MATCH_RECOGNIZE

CHANGELOG.md

@@ -30,6 +30,13 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
   `(a JOIN b) AS j`, registers only `j`. `ScopeVisitor::reference` reports
   the items inside the join at `depth + 1`, before the join itself, and
   subqueries in an unaliased join's conditions now get subquery scopes.
+- `build_scope` now registers an aliased table function FROM item, such as
+  `my_func(x) AS g(y, z)`, as a virtual source, so `g.y` qualifies and its
+  lineage reaches the function's arguments under a `_N` virtual source name.
+  Without a schema, an unqualified column is resolved among all FROM items,
+  the function included, so `SELECT a FROM t, my_func(t.x) AS g` no longer
+  assumes `t.a`. An aliased `MATCH_RECOGNIZE` is registered as its alias,
+  which hides its input relation.
 - `build_scope` now gives a subquery scope to a query in an expression field
   the scope walk skipped: an aggregate's `FILTER (WHERE ...)`, `ORDER BY` and
   `LIMIT`, a window frame bound, a `CAST` `FORMAT` or `DEFAULT` expression,

crates/polyglot-sql/src/lineage.rs

@@ -5022,6 +5022,29 @@ FROM UNNEST(GENERATE_DATE_ARRAY('2024-01-01', '2024-12-31', INTERVAL 1 WEEK)) AS
         );
     }
 
+    #[test]
+    fn test_lineage_aliased_table_function_is_a_virtual_source() {
+        let expr = parse_one(
+            "SELECT g.y AS out FROM t, my_func(t.x) AS g(y)",
+            DialectType::PostgreSQL,
+        )
+        .expect("parse");
+
+        let node = lineage("out", &expr, Some(DialectType::PostgreSQL), false).expect("lineage");
+        let child = node.downstream.first().expect("out should have lineage");
+
+        assert_eq!(child.name, "_0.y");
+        assert_eq!(child.source_kind, SourceKind::Virtual);
+        assert_eq!(child.source_alias.as_deref(), Some("g"));
+        assert!(
+            child
+                .downstream
+                .iter()
+                .any(|argument| argument.name == "t.x"),
+            "the function's argument should be lineage of its output"
+        );
+    }
+
     #[test]
     fn test_lineage_real_table_named_like_unnest_alias_is_not_virtual() {
         let expr =

crates/polyglot-sql/src/optimizer/qualify_columns.rs

@@ -3216,6 +3216,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_qualify_aliased_table_function_columns() {
+        let mut schema = MappingSchema::new();
+        schema
+            .add_table("t", &[("x".into(), DataType::Text)], None)
+            .unwrap();
+        let sql = "SELECT x, y FROM t, my_func(t.x) AS g(y)";
+        let qualified =
+            qualify_columns(parse(sql), &schema, &QualifyColumnsOptions::new()).unwrap();
+        assert_eq!(
+            gen(&qualified),
+            "SELECT t.x AS x, g.y AS y FROM t, MY_FUNC(t.x) AS g(y)"
+        );
+
+        // Without a column list the function's columns are unknown, but a
+        // reference qualified with its alias still resolves.
+        let sql = "SELECT x, g.z FROM t, my_func(t.x) AS g";
+        let qualified =
+            qualify_columns(parse(sql), &schema, &QualifyColumnsOptions::new()).unwrap();
+        assert_eq!(
+            gen(&qualified),
+            "SELECT t.x AS x, g.z AS z FROM t, MY_FUNC(t.x) AS g"
+        );
+    }
+
     #[test]
     fn test_get_scope_columns() {
         let expr = parse("SELECT a, b FROM t WHERE c = 1");

crates/polyglot-sql/src/resolver.rs

@@ -271,6 +271,9 @@ impl<'a> Resolver<'a> {
             Expression::Alias(alias) if matches!(&alias.this, Expression::Unnest(_)) => {
                 alias_output_columns(alias)
             }
+            Expression::Alias(alias) if matches!(&alias.this, Expression::Function(_)) => {
+                table_function_output_columns(alias)
+            }
             Expression::Alias(alias) => {
                 let columns = self.get_source_columns_for_expression(&alias.this)?;
                 apply_alias_columns(columns, &alias.column_aliases)
@@ -469,6 +472,9 @@ impl<'a> Resolver<'a> {
             Expression::Alias(alias) if matches!(&alias.this, Expression::Unnest(_)) => {
                 alias_output_columns(alias)
             }
+            Expression::Alias(alias) if matches!(&alias.this, Expression::Function(_)) => {
+                table_function_output_columns(alias)
+            }
             Expression::Alias(alias) => {
                 let columns = self.get_source_output_columns(&alias.this);
                 apply_alias_columns(columns, &alias.column_aliases)
@@ -697,15 +703,16 @@ fn unnest_output_columns(unnest: &crate::expressions::UnnestFunc) -> Vec<String>
         .collect()
 }
 
+/// A table function's output columns are unknown unless its alias lists them.
+fn table_function_output_columns(alias: &crate::expressions::Alias) -> Vec<String> {
+    identifier_names(&alias.column_aliases)
+}
+
 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()
+        identifier_names(&alias.column_aliases)
     }
 }
 
@@ -718,10 +725,13 @@ fn lateral_output_columns(lateral: &crate::expressions::Lateral) -> Vec<String>
 }
 
 fn lateral_view_output_columns(lateral_view: &crate::expressions::LateralView) -> Vec<String> {
-    lateral_view
-        .column_aliases
+    identifier_names(&lateral_view.column_aliases)
+}
+
+fn identifier_names(identifiers: &[Identifier]) -> Vec<String> {
+    identifiers
         .iter()
-        .map(|column| column.name.clone())
+        .map(|identifier| identifier.name.clone())
         .collect()
 }