Preserve order of START WITH / CONNECT BY; simplify parsing

Author: xitep

src/ast/mod.rs

@@ -85,7 +85,7 @@ pub use self::dml::{
 };
 pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
-    AfterMatchSkip, ConnectBy, Cte, CteAsMaterialized, Distinct, EmptyMatchesMode,
+    AfterMatchSkip, ConnectByKind, Cte, CteAsMaterialized, Distinct, EmptyMatchesMode,
     ExceptSelectItem, ExcludeSelectItem, ExprWithAlias, ExprWithAliasAndOrderBy, Fetch, ForClause,
     ForJson, ForXml, FormatClause, GroupByExpr, GroupByWithModifier, IdentWithAlias,
     IlikeSelectItem, InputFormatClause, Interpolate, InterpolateExpr, Join, JoinConstraint,

src/ast/query.rs

@@ -375,7 +375,7 @@ pub struct Select {
     /// WHERE
     pub selection: Option<Expr>,
     /// [START WITH ..] CONNECT BY ..
-    pub connect_by: Option<ConnectBy>,
+    pub connect_by: Vec<ConnectByKind>,
     /// GROUP BY
     pub group_by: GroupByExpr,
     /// CLUSTER BY (Hive)
@@ -475,9 +475,9 @@ impl fmt::Display for Select {
             SpaceOrNewline.fmt(f)?;
             Indent(selection).fmt(f)?;
         }
-        if let Some(ref connect_by) = self.connect_by {
+        for clause in &self.connect_by {
             SpaceOrNewline.fmt(f)?;
-            connect_by.fmt(f)?;
+            clause.fmt(f)?;
         }
         match &self.group_by {
             GroupByExpr::All(_) => {
@@ -1098,38 +1098,38 @@ impl fmt::Display for TableWithJoins {
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct ConnectBy {
+pub enum ConnectByKind {
+    /// CONNECT BY
+    ConnectBy {
+        /// the join conditions denoting the hierarchical relationship
+        relationships: Vec<Expr>,
+
+        /// [CONNECT BY] NOCYCLE
+        ///
+        /// Optional on [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Hierarchical-Queries.html#GUID-0118DF1D-B9A9-41EB-8556-C6E7D6A5A84E__GUID-5377971A-F518-47E4-8781-F06FEB3EF993)
+        nocycle: bool,
+    },
+
     /// START WITH
     ///
     /// Optional on [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Hierarchical-Queries.html#GUID-0118DF1D-B9A9-41EB-8556-C6E7D6A5A84E)
     /// when comming _after_ the `CONNECT BY`.
-    pub condition: Option<Expr>,
-
-    /// CONNECT BY
-    pub relationships: Vec<Expr>,
-
-    /// [CONNECT BY] NOCYCLE
-    ///
-    /// Optional on [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Hierarchical-Queries.html#GUID-0118DF1D-B9A9-41EB-8556-C6E7D6A5A84E__GUID-5377971A-F518-47E4-8781-F06FEB3EF993)
-    pub nocycle: bool,
+    StartWith(Box<Expr>),
 }
 
-impl fmt::Display for ConnectBy {
+impl fmt::Display for ConnectByKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let Self {
-            condition,
-            relationships,
-            nocycle,
-        } = self;
-        if let Some(condition) = condition {
-            write!(f, "START WITH {condition} ")?;
+        match self {
+            ConnectByKind::ConnectBy { relationships, nocycle } => {
+                write!(f, "CONNECT BY {nocycle}{relationships}",
+                    nocycle = if *nocycle { "NOCYCLE " } else { "" },
+                    relationships = display_comma_separated(relationships)
+                )
+            },
+            ConnectByKind::StartWith(condition) => {
+                write!(f, "START WITH {condition}")
+            },
         }
-        write!(
-            f,
-            "CONNECT BY {nocycle}{relationships}",
-            nocycle = if *nocycle { "NOCYCLE " } else { "" },
-            relationships = display_comma_separated(relationships)
-        )
     }
 }
 

src/ast/spans.rs

@@ -32,7 +32,7 @@ use super::{
     AlterIndexOperation, AlterTableOperation, Analyze, Array, Assignment, AssignmentTarget,
     AttachedToken, BeginEndStatements, CaseStatement, CloseCursor, ClusteredIndex, ColumnDef,
     ColumnOption, ColumnOptionDef, ConditionalStatementBlock, ConditionalStatements,
-    ConflictTarget, ConnectBy, ConstraintCharacteristics, CopySource, CreateIndex, CreateTable,
+    ConflictTarget, ConnectByKind, ConstraintCharacteristics, CopySource, CreateIndex, CreateTable,
     CreateTableOptions, Cte, Delete, DoUpdate, ExceptSelectItem, ExcludeSelectItem, Expr,
     ExprWithAlias, Fetch, ForValues, FromTable, Function, FunctionArg, FunctionArgExpr,
     FunctionArgumentClause, FunctionArgumentList, FunctionArguments, GroupByExpr, HavingBound,
@@ -2280,20 +2280,14 @@ impl Spanned for Select {
     }
 }
 
-impl Spanned for ConnectBy {
+impl Spanned for ConnectByKind {
     fn span(&self) -> Span {
-        let ConnectBy {
-            condition,
-            relationships,
-            nocycle: _,
-        } = self;
-
-        union_spans(
-            condition
-                .iter()
-                .map(Spanned::span)
-                .chain(relationships.iter().map(|item| item.span())),
-        )
+        match self {
+            ConnectByKind::ConnectBy { relationships, nocycle: _ } => {
+                union_spans(relationships.iter().map(|item| item.span()))
+            }
+            ConnectByKind::StartWith(expr) => expr.span(),
+        }
     }
 }
 

src/parser/mod.rs

@@ -13902,7 +13902,7 @@ impl<'a> Parser<'a> {
                     window_before_qualify: false,
                     qualify: None,
                     value_table_mode: None,
-                    connect_by: None,
+                    connect_by: vec![],
                     flavor: SelectFlavor::FromFirstNoSelect,
                 });
             }
@@ -14000,15 +14000,7 @@ impl<'a> Parser<'a> {
             None
         };
 
-        let connect_by = if self.dialect.supports_connect_by()
-            && self
-                .peek_one_of_keywords(&[Keyword::START, Keyword::CONNECT])
-                .is_some()
-        {
-            Some(self.parse_connect_by()?)
-        } else {
-            None
-        };
+        let connect_by = self.maybe_parse_connect_by()?;
 
         let group_by = self
             .parse_optional_group_by()?
@@ -14183,37 +14175,22 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse a `CONNECT BY` clause (Oracle-style hierarchical query support).
-    pub fn parse_connect_by(&mut self) -> Result<ConnectBy, ParserError> {
-        let (condition, relationships, nocycle) = if self
-            .parse_keywords(&[Keyword::CONNECT, Keyword::BY])
-        {
-            let (relationships, nocycle) = self.with_state(ParserState::ConnectBy, |parser| {
-                let nocycle = parser.parse_keyword(Keyword::NOCYCLE);
-                parser
-                    .parse_comma_separated(Parser::parse_expr)
-                    .map(|exprs| (exprs, nocycle))
-            })?;
-            let condition = if self.parse_keywords(&[Keyword::START, Keyword::WITH]) {
-                Some(self.parse_expr()?)
+    pub fn maybe_parse_connect_by(&mut self) -> Result<Vec<ConnectByKind>, ParserError> {
+        let mut clauses = Vec::with_capacity(2);
+        loop {
+            if self.parse_keywords(&[Keyword::START, Keyword::WITH]) {
+                clauses.push(ConnectByKind::StartWith(self.parse_expr()?.into()));
+            } else if self.parse_keywords(&[Keyword::CONNECT, Keyword::BY]) {
+                let nocycle = self.parse_keyword(Keyword::NOCYCLE);
+                let relationships = self.with_state(ParserState::ConnectBy, |parser| {
+                    parser.parse_comma_separated(Parser::parse_expr)
+                })?;
+                clauses.push(ConnectByKind::ConnectBy { relationships, nocycle });
             } else {
-                None
-            };
-            (condition, relationships, nocycle)
-        } else {
-            self.expect_keywords(&[Keyword::START, Keyword::WITH])?;
-            let condition = self.parse_expr()?;
-            self.expect_keywords(&[Keyword::CONNECT, Keyword::BY])?;
-            let nocycle = self.parse_keyword(Keyword::NOCYCLE);
-            let relationships = self.with_state(ParserState::ConnectBy, |parser| {
-                parser.parse_comma_separated(Parser::parse_expr)
-            })?;
-            (Some(condition), relationships, nocycle)
-        };
-        Ok(ConnectBy {
-            condition,
-            relationships,
-            nocycle,
-        })
+                break;
+            }
+        }
+        Ok(clauses)
     }
 
     /// Parse `CREATE TABLE x AS TABLE y`

tests/sqlparser_bigquery.rs

@@ -2710,7 +2710,7 @@ fn test_export_data() {
                     qualify: None,
                     window_before_qualify: false,
                     value_table_mode: None,
-                    connect_by: None,
+                    connect_by: vec![],
                     flavor: SelectFlavor::Standard,
                 }))),
                 order_by: Some(OrderBy {
@@ -2815,7 +2815,7 @@ fn test_export_data() {
                     qualify: None,
                     window_before_qualify: false,
                     value_table_mode: None,
-                    connect_by: None,
+                    connect_by: vec![],
                     flavor: SelectFlavor::Standard,
                 }))),
                 order_by: Some(OrderBy {

tests/sqlparser_clickhouse.rs

@@ -102,7 +102,7 @@ fn parse_map_access_expr() {
             window_before_qualify: false,
             qualify: None,
             value_table_mode: None,
-            connect_by: None,
+            connect_by: vec![],
             flavor: SelectFlavor::Standard,
         },
         select