Revert "support for CONNECT BY"

jmhain · jmhain · commit 858c7fe41de9 · 2024-04-29T20:03:32.000-07:00
This reverts commit 906ad24.
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -39,8 +39,8 @@ pub use self::ddl::{
 };
 pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
-    ConnectBy, Cte, CteAsMaterialized, Distinct, ExceptSelectItem, ExcludeSelectItem, Fetch,
-    ForClause, ForJson, ForXml, GroupByExpr, IdentWithAlias, Join, JoinConstraint, JoinOperator,
+    Cte, CteAsMaterialized, Distinct, ExceptSelectItem, ExcludeSelectItem, Fetch, ForClause,
+    ForJson, ForXml, GroupByExpr, IdentWithAlias, Join, JoinConstraint, JoinOperator,
     JsonTableColumn, JsonTableColumnErrorHandling, LateralView, LockClause, LockType,
     NamedWindowDefinition, NonBlock, Offset, OffsetRows, OrderByExpr, Query, RenameSelectItem,
     ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SetOperator,
@@ -737,8 +737,6 @@ pub enum Expr {
     ///
     /// See <https://docs.snowflake.com/en/sql-reference/constructs/where#joins-in-the-where-clause>.
     OuterJoin(Box<Expr>),
-    /// A reference to the prior level in a CONNECT BY clause.
-    Prior(Box<Expr>),
 }
 
 impl fmt::Display for CastFormat {
@@ -1215,7 +1213,6 @@ impl fmt::Display for Expr {
             Expr::OuterJoin(expr) => {
                 write!(f, "{expr} (+)")
             }
-            Expr::Prior(expr) => write!(f, "PRIOR {expr}"),
         }
     }
 }
diff --git a/src/ast/query.rs b/src/ast/query.rs
@@ -92,8 +92,6 @@ impl fmt::Display for Query {
 pub enum SetExpr {
     /// Restricted SELECT .. FROM .. HAVING (no ORDER BY or set operations)
     Select(Box<Select>),
-    /// SELECT .. FROM .. STARTING WITH .. CONNECT BY
-    ConnectBy(ConnectBy),
     /// Parenthesized SELECT subquery, which may include more set operations
     /// in its body and an optional ORDER BY / LIMIT.
     Query(Box<Query>),
@@ -114,7 +112,6 @@ impl fmt::Display for SetExpr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             SetExpr::Select(s) => write!(f, "{s}"),
-            SetExpr::ConnectBy(c) => write!(f, "{c}"),
             SetExpr::Query(q) => write!(f, "({q})"),
             SetExpr::Values(v) => write!(f, "{v}"),
             SetExpr::Insert(v) => write!(f, "{v}"),
@@ -705,36 +702,6 @@ 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>.
-#[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 {
-    /// SELECT
-    pub projection: Vec<SelectItem>,
-    /// FROM
-    pub from: Vec<TableWithJoins>,
-    /// START WITH
-    pub condition: Expr,
-    /// CONNECT BY
-    pub relationships: Vec<Expr>,
-}
-
-impl fmt::Display for ConnectBy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "SELECT {projection} FROM {from} START WITH {condition} CONNECT BY {relationships}",
-            projection = display_comma_separated(&self.projection),
-            from = display_comma_separated(&self.from),
-            condition = self.condition,
-            relationships = display_comma_separated(&self.relationships)
-        )
-    }
-}
-
 /// A table name or a parenthesized subquery with an optional alias
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
diff --git a/src/keywords.rs b/src/keywords.rs
@@ -798,9 +798,6 @@ pub const RESERVED_FOR_TABLE_ALIAS: &[Keyword] = &[
     Keyword::FOR,
     // for MYSQL PARTITION SELECTION
     Keyword::PARTITION,
-    // for Snowflake START WITH .. CONNECT BY
-    Keyword::START,
-    Keyword::CONNECT,
 ];
 
 /// Can't be used as a column alias, so that `SELECT <expr> alias`
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -256,22 +256,10 @@ impl ParserOptions {
     }
 }
 
-#[derive(Copy, Clone)]
-enum ParserState {
-    /// The default state of the parser.
-    Normal,
-    /// The state when parsing a CONNECT BY expression. This allows parsing
-    /// PRIOR expressions while still allowing prior as an identifier name
-    /// in other contexts.
-    ConnectBy,
-}
-
 pub struct Parser<'a> {
     tokens: Vec<TokenWithLocation>,
     /// The index of the first unprocessed token in `self.tokens`
     index: usize,
-    /// The current state of the parser.
-    state: ParserState,
     /// The current dialect to use
     dialect: &'a dyn Dialect,
     /// Additional options that allow you to mix & match behavior
@@ -302,7 +290,6 @@ impl<'a> Parser<'a> {
         Self {
             tokens: vec![],
             index: 0,
-            state: ParserState::Normal,
             dialect,
             recursion_counter: RecursionCounter::new(DEFAULT_REMAINING_DEPTH),
             options: ParserOptions::default(),
@@ -979,10 +966,6 @@ impl<'a> Parser<'a> {
                     self.prev_token();
                     self.parse_bigquery_struct_literal()
                 }
-                Keyword::PRIOR if matches!(self.state, ParserState::ConnectBy) => {
-                    let expr = self.parse_subexpr(Self::PLUS_MINUS_PREC)?;
-                    Ok(Expr::Prior(Box::new(expr)))
-                }
                 // Here `w` is a word, check if it's a part of a multi-part
                 // identifier, a function call, or a simple identifier:
                 _ => match self.peek_token().token {
@@ -7179,7 +7162,7 @@ impl<'a> Parser<'a> {
         // We parse the expression using a Pratt parser, as in `parse_expr()`.
         // Start by parsing a restricted SELECT or a `(subquery)`:
         let mut expr = if self.parse_keyword(Keyword::SELECT) {
-            self.parse_select()?
+            SetExpr::Select(Box::new(self.parse_select()?))
         } else if self.consume_token(&Token::LParen) {
             // CTEs are not allowed here, but the parser currently accepts them
             let subquery = self.parse_query()?;
@@ -7267,7 +7250,7 @@ impl<'a> Parser<'a> {
 
     /// Parse a restricted `SELECT` statement (no CTEs / `UNION` / `ORDER BY`),
     /// assuming the initial `SELECT` was already consumed
-    pub fn parse_select(&mut self) -> Result<SetExpr, ParserError> {
+    pub fn parse_select(&mut self) -> Result<Select, ParserError> {
         let value_table_mode =
             if dialect_of!(self is BigQueryDialect) && self.parse_keyword(Keyword::AS) {
                 if self.parse_keyword(Keyword::VALUE) {
@@ -7319,18 +7302,6 @@ impl<'a> Parser<'a> {
             vec![]
         };
 
-        if distinct.is_none()
-            && top.is_none()
-            && into.is_none()
-            && !from.is_empty()
-            && self
-                .parse_one_of_keywords(&[Keyword::START, Keyword::CONNECT])
-                .is_some()
-        {
-            self.prev_token();
-            return Ok(SetExpr::ConnectBy(self.parse_connect_by(projection, from)?));
-        }
-
         let mut lateral_views = vec![];
         loop {
             if self.parse_keywords(&[Keyword::LATERAL, Keyword::VIEW]) {
@@ -7414,7 +7385,7 @@ impl<'a> Parser<'a> {
             None
         };
 
-        Ok(SetExpr::Select(Box::new(Select {
+        Ok(Select {
             distinct,
             top,
             projection,
@@ -7430,48 +7401,6 @@ impl<'a> Parser<'a> {
             named_window: named_windows,
             qualify,
             value_table_mode,
-        })))
-    }
-
-    fn with_state<T, F>(&mut self, state: ParserState, mut f: F) -> Result<T, ParserError>
-    where
-        F: FnMut(&mut Parser) -> Result<T, ParserError>,
-    {
-        let current_state = self.state;
-        self.state = state;
-        let res = f(self);
-        self.state = current_state;
-        res
-    }
-
-    pub fn parse_connect_by(
-        &mut self,
-        projection: Vec<SelectItem>,
-        from: Vec<TableWithJoins>,
-    ) -> Result<ConnectBy, ParserError> {
-        debug_assert!(!from.is_empty());
-
-        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)
-            })?;
-            self.expect_keywords(&[Keyword::START, Keyword::WITH])?;
-            let condition = self.parse_expr()?;
-            (condition, relationships)
-        } else {
-            self.expect_keywords(&[Keyword::START, Keyword::WITH])?;
-            let condition = self.parse_expr()?;
-            self.expect_keywords(&[Keyword::CONNECT, Keyword::BY])?;
-            let relationships = self.with_state(ParserState::ConnectBy, |parser| {
-                parser.parse_comma_separated(Parser::parse_expr)
-            })?;
-            (condition, relationships)
-        };
-        Ok(ConnectBy {
-            projection,
-            from,
-            condition,
-            relationships,
         })
     }
 
diff --git a/src/test_utils.rs b/src/test_utils.rs
@@ -157,16 +157,6 @@ impl TestedDialects {
         }
     }
 
-    /// Ensures that `sql` parses as a single [Query], and that
-    /// re-serializing the parse result matches the given canonical
-    /// sql string.
-    pub fn verified_query_with_canonical(&self, query: &str, canonical: &str) -> Query {
-        match self.one_statement_parses_to(query, canonical) {
-            Statement::Query(query) => *query,
-            _ => panic!("Expected Query"),
-        }
-    }
-
     /// Ensures that `sql` parses as a single [Select], and that
     /// re-serializing the parse result produces the same `sql`
     /// string (is not modified after a serialization round-trip).
diff --git a/tests/sqlparser_snowflake.rs b/tests/sqlparser_snowflake.rs
@@ -1508,88 +1508,3 @@ fn parse_comma_outer_join() {
         "SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+)",
     );
 }
-
-#[test]
-fn parse_connect_by() {
-    let expect_query = Query {
-        with: None,
-        body: Box::new(SetExpr::ConnectBy(ConnectBy {
-            projection: vec![
-                SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("employee_id"))),
-                SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("manager_id"))),
-                SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))),
-            ],
-            from: vec![TableWithJoins {
-                relation: TableFactor::Table {
-                    name: ObjectName(vec![Ident::new("employees")]),
-                    alias: None,
-                    args: None,
-                    with_hints: vec![],
-                    version: None,
-                    partitions: vec![],
-                },
-                joins: vec![],
-            }],
-            condition: Expr::BinaryOp {
-                left: Box::new(Expr::Identifier(Ident::new("title"))),
-                op: BinaryOperator::Eq,
-                right: Box::new(Expr::Value(Value::SingleQuotedString(
-                    "president".to_owned(),
-                ))),
-            },
-            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",
-                ))))),
-            }],
-        })),
-        order_by: vec![OrderByExpr {
-            expr: Expr::Identifier(Ident::new("employee_id")),
-            asc: None,
-            nulls_first: None,
-        }],
-        limit: None,
-        limit_by: vec![],
-        offset: None,
-        fetch: None,
-        locks: vec![],
-        for_clause: None,
-    };
-
-    let connect_by_1 = concat!(
-        "SELECT employee_id, manager_id, title FROM employees ",
-        "START WITH title = 'president' ",
-        "CONNECT BY manager_id = PRIOR employee_id ",
-        "ORDER BY employee_id"
-    );
-
-    assert_eq!(
-        snowflake_and_generic().verified_query(connect_by_1),
-        expect_query
-    );
-
-    // CONNECT BY can come before START WITH
-    let connect_by_2 = concat!(
-        "SELECT employee_id, manager_id, title FROM employees ",
-        "CONNECT BY manager_id = PRIOR employee_id ",
-        "START WITH title = 'president' ",
-        "ORDER BY employee_id"
-    );
-    assert_eq!(
-        snowflake_and_generic().verified_query_with_canonical(connect_by_2, connect_by_1),
-        expect_query
-    );
-
-    // PRIOR expressions are only valid within a CONNECT BY, and the the token
-    // `prior` is valid as an identifier anywhere else.
-    assert_eq!(
-        snowflake_and_generic()
-            .verified_only_select("SELECT prior FROM some_table")
-            .projection,
-        vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident::new(
-            "prior"
-        )))]
-    );
-}

Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,8 @@ pub use self::ddl::{`
`39`	`39`	`};`
`40`	`40`	`pub use self::operator::{BinaryOperator, UnaryOperator};`
`41`	`41`	`pub use self::query::{`
`42`		`- ConnectBy, Cte, CteAsMaterialized, Distinct, ExceptSelectItem, ExcludeSelectItem, Fetch,`
`43`		`- ForClause, ForJson, ForXml, GroupByExpr, IdentWithAlias, Join, JoinConstraint, JoinOperator,`
	`42`	`+ Cte, CteAsMaterialized, Distinct, ExceptSelectItem, ExcludeSelectItem, Fetch, ForClause,`
	`43`	`+ ForJson, ForXml, GroupByExpr, IdentWithAlias, Join, JoinConstraint, JoinOperator,`
`44`	`44`	`JsonTableColumn, JsonTableColumnErrorHandling, LateralView, LockClause, LockType,`
`45`	`45`	`NamedWindowDefinition, NonBlock, Offset, OffsetRows, OrderByExpr, Query, RenameSelectItem,`
`46`	`46`	`ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SetOperator,`
`@@ -737,8 +737,6 @@ pub enum Expr {`
`737`	`737`	`///`
`738`	`738`	`/// See <https://docs.snowflake.com/en/sql-reference/constructs/where#joins-in-the-where-clause>.`
`739`	`739`	`OuterJoin(Box<Expr>),`
`740`		`- /// A reference to the prior level in a CONNECT BY clause.`
`741`		`- Prior(Box<Expr>),`
`742`	`740`	`}`
`743`	`741`
`744`	`742`	`impl fmt::Display for CastFormat {`
`@@ -1215,7 +1213,6 @@ impl fmt::Display for Expr {`
`1215`	`1213`	`Expr::OuterJoin(expr) => {`
`1216`	`1214`	`write!(f, "{expr} (+)")`
`1217`	`1215`	`}`
`1218`		`- Expr::Prior(expr) => write!(f, "PRIOR {expr}"),`
`1219`	`1216`	`}`
`1220`	`1217`	`}`
`1221`	`1218`	`}`