MySQL: Support CROSS JOIN <table> [ON | USING] ...

Author: rs-sac

src/ast/query.rs

@@ -2333,7 +2333,11 @@ impl fmt::Display for Join {
                 self.relation,
                 suffix(constraint)
             )),
-            JoinOperator::CrossJoin => f.write_fmt(format_args!("CROSS JOIN {}", self.relation)),
+            JoinOperator::CrossJoin(constraint) => f.write_fmt(format_args!(
+                "CROSS JOIN {}{}",
+                self.relation,
+                suffix(constraint)
+            )),
             JoinOperator::Semi(constraint) => f.write_fmt(format_args!(
                 "{}SEMI JOIN {}{}",
                 prefix(constraint),
@@ -2400,7 +2404,8 @@ pub enum JoinOperator {
     Right(JoinConstraint),
     RightOuter(JoinConstraint),
     FullOuter(JoinConstraint),
-    CrossJoin,
+    /// CROSS (constraint is non-standard)
+    CrossJoin(JoinConstraint),
     /// SEMI (non-standard)
     Semi(JoinConstraint),
     /// LEFT SEMI (non-standard)

src/ast/spans.rs

@@ -2226,7 +2226,7 @@ impl Spanned for JoinOperator {
             JoinOperator::Right(join_constraint) => join_constraint.span(),
             JoinOperator::RightOuter(join_constraint) => join_constraint.span(),
             JoinOperator::FullOuter(join_constraint) => join_constraint.span(),
-            JoinOperator::CrossJoin => Span::empty(),
+            JoinOperator::CrossJoin(join_constraint) => join_constraint.span(),
             JoinOperator::LeftSemi(join_constraint) => join_constraint.span(),
             JoinOperator::RightSemi(join_constraint) => join_constraint.span(),
             JoinOperator::LeftAnti(join_constraint) => join_constraint.span(),

src/dialect/mod.rs

@@ -311,6 +311,11 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports a join specification on CROSS JOIN.
+    fn supports_cross_join_constraint(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports CONNECT BY.
     fn supports_connect_by(&self) -> bool {
         false

src/dialect/mysql.rs

@@ -163,6 +163,10 @@ impl Dialect for MySqlDialect {
     fn supports_data_type_signed_suffix(&self) -> bool {
         true
     }
+
+    fn supports_cross_join_constraint(&self) -> bool {
+        true
+    }
 }
 
 /// `LOCK TABLES`

src/parser/mod.rs

@@ -13317,15 +13317,24 @@ impl<'a> Parser<'a> {
             let global = self.parse_keyword(Keyword::GLOBAL);
             let join = if self.parse_keyword(Keyword::CROSS) {
                 let join_operator = if self.parse_keyword(Keyword::JOIN) {
-                    JoinOperator::CrossJoin
+                    JoinOperator::CrossJoin(JoinConstraint::None)
                 } else if self.parse_keyword(Keyword::APPLY) {
                     // MSSQL extension, similar to CROSS JOIN LATERAL
                     JoinOperator::CrossApply
                 } else {
                     return self.expected("JOIN or APPLY after CROSS", self.peek_token());
                 };
+                let relation = self.parse_table_factor()?;
+                let join_operator = if matches!(join_operator, JoinOperator::CrossJoin(_))
+                    && self.dialect.supports_cross_join_constraint()
+                {
+                    let constraint = self.parse_join_constraint(false)?;
+                    JoinOperator::CrossJoin(constraint)
+                } else {
+                    join_operator
+                };
                 Join {
-                    relation: self.parse_table_factor()?,
+                    relation,
                     global,
                     join_operator,
                 }

tests/sqlparser_common.rs

@@ -7131,7 +7131,7 @@ fn parse_cross_join() {
         Join {
             relation: table_from_name(ObjectName::from(vec![Ident::new("t2")])),
             global: false,
-            join_operator: JoinOperator::CrossJoin,
+            join_operator: JoinOperator::CrossJoin(JoinConstraint::None),
         },
         only(only(select.from).joins),
     );

tests/sqlparser_mysql.rs

@@ -4132,6 +4132,40 @@ fn parse_straight_join() {
         .verified_stmt("SELECT a.*, b.* FROM table_a STRAIGHT_JOIN table_b AS b ON a.b_id = b.id");
 }
 
+#[test]
+fn parse_cross_join_on() {
+    let sql = "SELECT * FROM t1 CROSS JOIN t2 ON a = b";
+    let select = mysql().verified_only_select(sql);
+    assert_eq!(
+        Join {
+            relation: table_from_name(ObjectName::from(vec![Ident::new("t2")])),
+            global: false,
+            join_operator: JoinOperator::CrossJoin(JoinConstraint::On(Expr::BinaryOp {
+                left: Box::new(Expr::Identifier(Ident::new("a"))),
+                op: BinaryOperator::Eq,
+                right: Box::new(Expr::Identifier(Ident::new("b"))),
+            })),
+        },
+        only(only(select.from).joins),
+    );
+}
+
+#[test]
+fn parse_cross_join_using() {
+    let sql = "SELECT * FROM t1 CROSS JOIN t2 USING(a)";
+    let select = mysql().verified_only_select(sql);
+    assert_eq!(
+        Join {
+            relation: table_from_name(ObjectName::from(vec![Ident::new("t2")])),
+            global: false,
+            join_operator: JoinOperator::CrossJoin(JoinConstraint::Using(vec![ObjectName::from(
+                vec![Ident::new("a")]
+            )],)),
+        },
+        only(only(select.from).joins),
+    );
+}
+
 #[test]
 fn mysql_foreign_key_with_index_name() {
     mysql().verified_stmt(