Type native Postgres trees as PostgreSQL 18.6 does, and drop follow-on findings

crates/sqlquack-semantics/Cargo.toml

@@ -16,5 +16,8 @@ sqlquack-syntax.workspace = true
 sqlquack-core.workspace = true
 sqlquack-snowflake.workspace = true
 
+[dev-dependencies]
+sqlquack-syntax-postgres.workspace = true
+
 [lints]
 workspace = true

crates/sqlquack-semantics/src/lineage/_helpers/findings/checks.rs

@@ -87,7 +87,12 @@ pub(crate) fn column_finding(
                 ),
             ));
         }
-        if matches >= 1 || current.sources.iter().any(unjudged) {
+        if matches >= 1
+            || current
+                .sources
+                .iter()
+                .any(|source| unjudged(source) || source.query.faulted)
+        {
             return None;
         }
         scope = current.outer;
@@ -120,7 +125,10 @@ fn qualified_finding(
     let mut scope: Option<&LineageScope<'_>> = Some(level.scope);
     while let Some(current) = scope {
         if let Some(source) = source_named(current, &alias, context) {
-            return (!unjudged(source) && !offers(source, wanted, context)).then(|| {
+            return (!unjudged(source)
+                && !source.query.faulted
+                && !offers(source, wanted, context))
+            .then(|| {
                 (
                     UNKNOWN_COLUMN_CODE,
                     format!(

crates/sqlquack-semantics/src/lineage/_helpers/findings/levels.rs

@@ -61,26 +61,61 @@ pub(crate) fn query_findings(
     }
 }
 
-/// The CTEs `with` adds to `ctes`, and each body's findings made with the CTEs before it.
+/// The CTEs `with` adds to `ctes`, each body's findings, and under PostgreSQL each one faulted.
 fn visited_ctes<'a>(
     with: Option<&With>,
     (ctes, outer, aliases): (&'a [NamedQuery], Option<&LineageScope<'_>>, &[String]),
     context: LineageContext<'_>,
 ) -> (Cow<'a, [NamedQuery]>, Vec<NameFinding>) {
     let mut found: Vec<NameFinding> = Vec::new();
+    let postgres: bool = Engine::of(context) == Engine::Postgres;
     let reach = with_ctes_visiting(with, (ctes, outer), context, &mut |cte, reach| {
-        found.extend(query_findings(&cte.this, (reach, outer, aliases), context));
+        let body: Vec<NameFinding> = query_findings(&cte.this, (reach, outer, aliases), context);
+        let faulted: bool =
+            postgres && (!body.is_empty() || reads_faulted(&cte.this, reach, context));
+        found.extend(body);
+        faulted
     });
     (reach, found)
 }
 
+/// The key of a derived table in FROM, by its alias; none when `item` is not a derived table.
+fn derived_key(item: &Expression, context: LineageContext<'_>) -> Option<Option<String>> {
+    match item {
+        Expression::Subquery(subquery) => {
+            Some(subquery.alias.as_ref().map(|alias| key(alias, context)))
+        }
+        Expression::Alias(alias) if matches!(alias.this, Expression::Subquery(_)) => {
+            Some(Some(key(&alias.alias, context)))
+        }
+        _ => None,
+    }
+}
+
+/// Whether `query` names a faulted CTE among `reach`.
+fn reads_faulted(query: &Expression, reach: &[NamedQuery], context: LineageContext<'_>) -> bool {
+    query.dfs().any(|node| match node {
+        Expression::Table(table) if table.schema.is_none() && table.catalog.is_none() => {
+            faulted_cte(&key(&table.name, context), reach, context)
+        }
+        _ => false,
+    })
+}
+
+/// Whether the CTE `name` resolves to among `reach` is faulted.
+fn faulted_cte(name: &str, reach: &[NamedQuery], context: LineageContext<'_>) -> bool {
+    reach
+        .iter()
+        .any(|named| named.query.faulted && context.profile.same_identifier(&named.key, name))
+}
+
 fn select_findings(
     (node, select): (&Expression, &Select),
     (ctes, outer, aliases): (&[NamedQuery], Option<&LineageScope<'_>>, &[String]),
     context: LineageContext<'_>,
 ) -> Vec<NameFinding> {
     let (ctes, mut nested) = visited_ctes(select.with.as_ref(), (ctes, outer, aliases), context);
-    let scope: LineageScope<'_> = level_scope(select, &ctes, outer, context);
+    let mut scope: LineageScope<'_> = level_scope(select, &ctes, outer, context);
     let level = NodeLevel {
         scope: &scope,
         context,
@@ -97,13 +132,22 @@ fn select_findings(
     }
     let mut own: Vec<NameFinding> = alias_count_findings(select, &scope, context);
     own.extend(using_findings(select, &scope, context));
+    let postgres: bool = Engine::of(context) == Engine::Postgres;
     for item in from_items(select) {
         let reads: Option<&LineageScope<'_>> = lateral(item).then_some(&scope);
-        nested.extend(query_findings(
-            unannotated(item),
-            (&ctes, reads, aliases),
-            context,
-        ));
+        let body: Vec<NameFinding> =
+            query_findings(unannotated(item), (&ctes, reads, aliases), context);
+        if let Some(derived) = derived_key(unannotated(item), context)
+            && postgres
+            && (!body.is_empty() || reads_faulted(item, &ctes, context))
+        {
+            scope
+                .sources
+                .iter_mut()
+                .filter(|source| source.query.derived && source.key == derived)
+                .for_each(|source| source.query.faulted = true);
+        }
+        nested.extend(body);
         own.extend(unpivot_findings(item, &ctes, context));
     }
     let mut outputs: Vec<String> = aliases.to_vec();
@@ -124,7 +168,6 @@ fn select_findings(
             )
         }),
     };
-    let postgres: bool = Engine::of(context) == Engine::Postgres;
     let unnamed: [String; 0] = [];
     for projection in &select.expressions {
         let own_name: String = output_key(unannotated(projection), context);

crates/sqlquack-semantics/src/lineage/_helpers/tracing/queries.rs

@@ -274,31 +274,32 @@ pub(crate) fn with_ctes<'a>(
     outer: Option<&LineageScope<'_>>,
     context: LineageContext<'_>,
 ) -> Cow<'a, [NamedQuery]> {
-    with_ctes_visiting(with, (ctes, outer), context, &mut |_, _| {})
+    with_ctes_visiting(with, (ctes, outer), context, &mut |_, _| false)
 }
 
 /// `with_ctes`, showing `visit` each CTE with the CTEs its body can read.
 pub(crate) fn with_ctes_visiting<'a>(
     with: Option<&With>,
     (ctes, outer): (&'a [NamedQuery], Option<&LineageScope<'_>>),
     context: LineageContext<'_>,
-    visit: &mut dyn FnMut(&Cte, &[NamedQuery]),
+    visit: &mut dyn FnMut(&Cte, &[NamedQuery]) -> bool,
 ) -> Cow<'a, [NamedQuery]> {
     let Some(with) = with else {
         return Cow::Borrowed(ctes);
     };
     let mut reach: Vec<NamedQuery> = ctes.to_vec();
     for cte in &with.ctes {
-        visit(cte, &reach);
+        let faulted: bool = visit(cte, &reach);
         let name = key(&cte.alias, context);
-        let query: ResolvedQuery = match with.recursive || reads_itself(cte, &name, context) {
+        let mut query: ResolvedQuery = match with.recursive || reads_itself(cte, &name, context) {
             true => recursive_query(cte, (&name, &reach), outer, context),
             false => renamed(
                 resolved_query(&cte.this, &reach, outer, context),
                 &cte.columns,
                 context,
             ),
         };
+        query.faulted = faulted;
         reach.retain(|named| named.key != name);
         reach.push(NamedQuery { key: name, query });
     }
@@ -709,6 +710,7 @@ pub(crate) fn expanded_star(
         rows: RowReads::default(),
         outer_nullable: only.is_some_and(|only| only.query.outer_nullable),
         derived: false,
+        faulted: false,
     }
 }