feat(convert): run FULL JOIN USING after a JOIN without ON left to right

Snowflake binds a later FULL JOIN ... USING to the whole join so far,
as it does a later ON: after a join without ON, the recorded cases return
the left-to-right row count, not the nested one. The conversion no longer
refuses that shape. RIGHT JOIN with USING and RIGHT JOIN without ON stay
refused. The recorded cases are in the pinned evidence, and the translation
results baseline gains their two statements.

Author: kvlonge

coverage/translation/results-baseline.json

@@ -6649,6 +6649,8 @@
     "relational/cross_join_then_outer_join.toml#cross_join_then_full_join_on_first_table": "matching",
     "relational/cross_join_then_outer_join.toml#cross_join_then_right_join_on": "matching",
     "relational/cross_join_then_outer_join.toml#join_without_on_then_full_join_on": "matching",
+    "relational/cross_join_then_outer_join.toml#join_without_on_then_full_join_using": "matching",
+    "relational/cross_join_then_outer_join.toml#join_without_on_then_right_join_using": "refused",
     "relational/fixture_shapes.toml#not_in_subquery_filtered_not_null_in_case": "matching_rejection",
     "relational/fixture_shapes.toml#not_in_subquery_in_case": "matching_rejection",
     "relational/fixture_shapes.toml#not_in_subquery_of_literal_rows_in_case": "matching",

crates/sqlquack-convert/src/snowflake/catalogue/constants.rs

@@ -149,7 +149,7 @@ pub const RULES: &[RuleSpec] = &[
             "join:left",
             "join:full",
         ],
-        conditions: "No condition: CROSS JOIN, a comma, or JOIN, INNER JOIN, LEFT JOIN or FULL JOIN without ON, which Snowflake runs as a cross join, with no rows when either side is empty, as recorded; a later RIGHT or FULL JOIN with ON applies to the whole join before it, as recorded; one before a FULL JOIN with USING refuses, as that is unrecorded.",
+        conditions: "No condition: CROSS JOIN, a comma, or JOIN, INNER JOIN, LEFT JOIN or FULL JOIN without ON, which Snowflake runs as a cross join, with no rows when either side is empty, as recorded; a later RIGHT or FULL JOIN with ON, or FULL JOIN with USING, applies to the whole join before it, as recorded.",
         failures: &[],
     },
     RuleSpec {

crates/sqlquack-convert/src/snowflake/conversion/_helpers/queries/sources.rs

@@ -123,12 +123,10 @@ pub(crate) fn convert_from(
         sql.push_str(&source_sql);
         relations.push(relation);
     }
-    let joins = list(select, "joins");
-    for (index, join) in joins.iter().enumerate() {
+    for join in list(select, "joins") {
         let before = events();
         let merging = RefCell::new(None);
-        let using_follows = joins[index + 1..].iter().any(full_join_using);
-        let joined = convert_join(join, &relations, (outer, &merging, using_follows), context)
+        let joined = convert_join(join, &relations, (outer, &merging), context)
             .map_err(|refusal| context.locator.placed(refusal, join));
         let source = join.get("this").unwrap_or(&Value::Null);
         let (join_sql, relation) = recovered(joined, source, (before, relations.len()))?;
@@ -170,19 +168,10 @@ struct Merging {
     relation: Option<ScopeRelation>,
 }
 
-/// Whether `join` is a FULL JOIN with USING, whose binding after a join without ON is unrecorded.
-fn full_join_using(join: &Value) -> bool {
-    join.get("kind").and_then(Value::as_str) == Some("Full")
-        && join
-            .get("using")
-            .and_then(Value::as_array)
-            .is_some_and(|using| !using.is_empty())
-}
-
 fn convert_join(
     join: &Value,
     earlier: &[ScopeRelation],
-    (outer, merging, using_follows): (Option<&Scope<'_>>, &RefCell<Option<Merging>>, bool),
+    (outer, merging): (Option<&Scope<'_>>, &RefCell<Option<Merging>>),
     context: &Context<'_>,
 ) -> Result<(String, ScopeRelation), Refusal> {
     let join_construct = node_construct("join");
@@ -234,14 +223,6 @@ fn convert_join(
         ("Left", Some(_)) => "LEFT JOIN",
         ("Right", Some(_)) => "RIGHT JOIN",
         ("Full", Some(_)) => "FULL JOIN",
-        ("Inner" | "Left" | "Full", None) if using_follows => {
-            return Err(missing(
-                Construct::new(ConstructFamily::Join, kind.to_ascii_lowercase()),
-                format!(
-                    "a {kind} join without ON before a FULL JOIN with USING, which no receipt records"
-                ),
-            ));
-        }
         ("Cross" | "Inner" | "Left" | "Full", None) => "CROSS JOIN",
         ("Implicit", None) => ",",
         _ => {

crates/sqlquack/tests/cli/test_joins.rs

@@ -52,6 +52,12 @@ fn given_join_without_on_when_converted_and_run_on_duckdb_then_it_is_a_cross_joi
                   LEFT JOIN (SELECT 1 AS k) r RIGHT JOIN (SELECT 1 AS k2 UNION ALL SELECT 9) w ON w.k2 = r.k",
             expected_value: "3",
         },
+        ValueTestCase {
+            description: "a FULL JOIN with USING after a JOIN without ON applies to the whole join so far, as recorded",
+            sql: "SELECT TO_VARCHAR(COUNT(*)) AS n FROM (SELECT 1 AS x UNION ALL SELECT 2) a \
+                  JOIN (SELECT 1 AS k) r FULL JOIN (SELECT 1 AS k UNION ALL SELECT 9) w USING (k)",
+            expected_value: "3",
+        },
         ValueTestCase {
             description: "FULL JOIN without ON over two non-empty sides pairs every row",
             sql: "SELECT TO_VARCHAR(COUNT(*)) AS n FROM (SELECT 1 AS x UNION ALL SELECT 2) l \
@@ -71,23 +77,13 @@ fn given_join_without_on_when_converted_and_run_on_duckdb_then_it_is_a_cross_joi
 
 #[test]
 fn given_a_join_without_on_snowflake_has_not_recorded_when_converting_then_it_refuses() {
-    let test_cases = [
-        ConvertTestCase {
-            description: "RIGHT JOIN without ON, which no receipt records, refuses",
-            sql: "SELECT l.x AS x FROM (SELECT 1 AS x) l RIGHT JOIN (SELECT 1 AS y) r",
-            flags: &[],
-            mention: "no rule converts a Right join of this shape",
-            expected_outcome: convert_outcome(1, false),
-        },
-        ConvertTestCase {
-            description: "a JOIN without ON before a FULL JOIN with USING, which no receipt records, refuses",
-            sql: "SELECT a.x AS x FROM (SELECT 1 AS x) a JOIN (SELECT 1 AS k) r \
-                  FULL JOIN (SELECT 1 AS k) w USING (k)",
-            flags: &[],
-            mention: "before a FULL JOIN with USING",
-            expected_outcome: convert_outcome(1, false),
-        },
-    ];
+    let test_cases = [ConvertTestCase {
+        description: "RIGHT JOIN without ON, which no receipt records, refuses",
+        sql: "SELECT l.x AS x FROM (SELECT 1 AS x) l RIGHT JOIN (SELECT 1 AS y) r",
+        flags: &[],
+        mention: "no rule converts a Right join of this shape",
+        expected_outcome: convert_outcome(1, false),
+    }];
     for test_case in test_cases {
         assert_eq!(
             run_convert(test_case.sql, test_case.flags, test_case.mention),