[Oracle] Optional START WITH for CONNECT BY

Author: xitep

src/ast/query.rs

@@ -1204,23 +1204,34 @@ impl fmt::Display for TableWithJoins {
 /// Joins a table to itself to process hierarchical data in the table.
 ///
 /// See <https://docs.snowflake.com/en/sql-reference/constructs/connect-by>.
+/// See <https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Hierarchical-Queries.html>
 #[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 {
     /// START WITH
-    pub condition: Expr,
+    pub condition: Option<Expr>,
     /// CONNECT BY
     pub relationships: Vec<Expr>,
+    /// [CONNECT BY] NOCYCLE
+    pub nocycle: bool,
 }
 
 impl fmt::Display for ConnectBy {
     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} ")?;
+        }
         write!(
             f,
-            "START WITH {condition} CONNECT BY {relationships}",
-            condition = self.condition,
-            relationships = display_comma_separated(&self.relationships)
+            "CONNECT BY {nocycle}{relationships}",
+            nocycle = if *nocycle { "NOCYCLE " } else { "" },
+            relationships = display_comma_separated(relationships)
         )
     }
 }

src/ast/spans.rs

@@ -2286,10 +2286,11 @@ impl Spanned for ConnectBy {
         let ConnectBy {
             condition,
             relationships,
+            nocycle: _
         } = self;
 
         union_spans(
-            core::iter::once(condition.span()).chain(relationships.iter().map(|item| item.span())),
+            condition.iter().map(Spanned::span).chain(relationships.iter().map(|item| item.span())),
         )
     }
 }

src/keywords.rs

@@ -678,6 +678,7 @@ define_keywords!(
     NOCOMPRESS,
     NOCREATEDB,
     NOCREATEROLE,
+    NOCYCLE,
     NOINHERIT,
     NOLOGIN,
     NONE,

src/parser/mod.rs

@@ -14280,25 +14280,31 @@ 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) = if self.parse_keywords(&[Keyword::CONNECT, Keyword::BY]) {
-            let relationships = self.with_state(ParserState::ConnectBy, |parser| {
-                parser.parse_comma_separated(Parser::parse_expr)
+        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))
             })?;
-            self.expect_keywords(&[Keyword::START, Keyword::WITH])?;
-            let condition = self.parse_expr()?;
-            (condition, relationships)
+            let condition = if self.parse_keywords(&[Keyword::START, Keyword::WITH]) {
+                Some(self.parse_expr()?)
+            } 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)
             })?;
-            (condition, relationships)
+            (Some(condition), relationships, nocycle)
         };
         Ok(ConnectBy {
             condition,
             relationships,
+            nocycle
         })
     }
 

tests/sqlparser_common.rs

@@ -12675,20 +12675,21 @@ fn parse_connect_by() {
         window_before_qualify: false,
         value_table_mode: None,
         connect_by: Some(ConnectBy {
-            condition: Expr::BinaryOp {
+            condition: Some(Expr::BinaryOp {
                 left: Box::new(Expr::Identifier(Ident::new("title"))),
                 op: BinaryOperator::Eq,
                 right: Box::new(Expr::Value(
                     Value::SingleQuotedString("president".to_owned()).with_empty_span(),
                 )),
-            },
+            }),
             relationships: vec![Expr::BinaryOp {
                 left: Box::new(Expr::Identifier(Ident::new("manager_id"))),
                 op: BinaryOperator::Eq,
                 right: Box::new(Expr::Prior(Box::new(Expr::Identifier(Ident::new(
                     "employee_id",
                 ))))),
             }],
+            nocycle: false,
         }),
         flavor: SelectFlavor::Standard,
     };
@@ -12763,20 +12764,21 @@ fn parse_connect_by() {
             window_before_qualify: false,
             value_table_mode: None,
             connect_by: Some(ConnectBy {
-                condition: Expr::BinaryOp {
+                condition: Some(Expr::BinaryOp {
                     left: Box::new(Expr::Identifier(Ident::new("title"))),
                     op: BinaryOperator::Eq,
                     right: Box::new(Expr::Value(
                         (Value::SingleQuotedString("president".to_owned(),)).with_empty_span()
                     )),
-                },
+                }),
                 relationships: vec![Expr::BinaryOp {
                     left: Box::new(Expr::Identifier(Ident::new("manager_id"))),
                     op: BinaryOperator::Eq,
                     right: Box::new(Expr::Prior(Box::new(Expr::Identifier(Ident::new(
                         "employee_id",
                     ))))),
                 }],
+                nocycle: false,
             }),
             flavor: SelectFlavor::Standard,
         }
@@ -12803,6 +12805,51 @@ fn parse_connect_by() {
             "prior"
         )))]
     );
+
+    // no START WITH and NOCYCLE
+    let connect_by_5 = "SELECT child, parent FROM t CONNECT BY NOCYCLE parent = PRIOR child";
+    assert_eq!(
+        all_dialects_where(|d| d.supports_connect_by()).verified_only_select(connect_by_5),
+        Select {
+            select_token: AttachedToken::empty(),
+            optimizer_hint: None,
+            distinct: None,
+            top: None,
+            top_before_distinct: false,
+            projection: vec![
+                SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("child"))),
+                SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("parent"))),
+            ],
+            exclude: None,
+            from: vec![TableWithJoins {
+                relation: table_from_name(ObjectName::from(vec![Ident::new("t")])),
+                joins: vec![],
+            }],
+            into: None,
+            lateral_views: vec![],
+            prewhere: None,
+            selection: None,
+            group_by: GroupByExpr::Expressions(vec![], vec![]),
+            cluster_by: vec![],
+            distribute_by: vec![],
+            sort_by: vec![],
+            having: None,
+            named_window: vec![],
+            qualify: None,
+            window_before_qualify: false,
+            value_table_mode: None,
+            connect_by: Some(ConnectBy {
+                condition: None,
+                relationships: vec![Expr::BinaryOp {
+                    left: Expr::Identifier(Ident::new("parent")).into(),
+                    op: BinaryOperator::Eq,
+                    right: Expr::Prior(Expr::Identifier(Ident::new("child")).into()).into(),
+                }],
+                nocycle: true,
+            }),
+            flavor: SelectFlavor::Standard,
+        }
+    );
 }
 
 #[test]