move parsing to dedicated function

Author: simonvandel

src/parser/mod.rs

@@ -10321,87 +10321,7 @@ impl<'a> Parser<'a> {
                 None
             };
 
-            let mut pipe_operators = Vec::new();
-
-            while self.consume_token(&Token::VerticalBarRightAngleBracket) {
-                let kw = self.expect_one_of_keywords(&[
-                    Keyword::SELECT,
-                    Keyword::EXTEND,
-                    Keyword::SET,
-                    Keyword::DROP,
-                    Keyword::AS,
-                    Keyword::WHERE,
-                    Keyword::LIMIT,
-                    Keyword::AGGREGATE,
-                    Keyword::ORDER,
-                ])?;
-                match kw {
-                    Keyword::SELECT => {
-                        let exprs = self.parse_comma_separated(Parser::parse_select_item)?;
-                        pipe_operators.push(PipeOperator::Select { exprs })
-                    }
-                    Keyword::EXTEND => {
-                        let exprs = self.parse_comma_separated(Parser::parse_select_item)?;
-                        pipe_operators.push(PipeOperator::Extend { exprs })
-                    }
-                    Keyword::SET => {
-                        let assignments = self.parse_comma_separated(Parser::parse_assignment)?;
-                        pipe_operators.push(PipeOperator::Set { assignments })
-                    }
-                    Keyword::DROP => {
-                        let columns = self.parse_identifiers()?;
-                        pipe_operators.push(PipeOperator::Drop { columns })
-                    }
-                    Keyword::AS => {
-                        let alias = self.parse_identifier()?;
-                        pipe_operators.push(PipeOperator::As { alias })
-                    }
-                    Keyword::WHERE => {
-                        let expr = self.parse_expr()?;
-                        pipe_operators.push(PipeOperator::Where { expr })
-                    }
-                    Keyword::LIMIT => {
-                        let expr = self.parse_expr()?;
-                        let offset = if self.parse_keyword(Keyword::OFFSET) {
-                            Some(self.parse_expr()?)
-                        } else {
-                            None
-                        };
-                        pipe_operators.push(PipeOperator::Limit { expr, offset })
-                    }
-                    Keyword::AGGREGATE => {
-                        let full_table_exprs = self.parse_comma_separated0(
-                            |parser| {
-                                let expr = parser.parse_expr()?;
-                                let alias = parser.maybe_parse_select_item_alias()?;
-                                Ok(ExprWithAlias { expr, alias })
-                            },
-                            Token::make_keyword(keywords::GROUP),
-                        )?;
-
-                        let group_by_exprs = if self.parse_keywords(&[Keyword::GROUP, Keyword::BY])
-                        {
-                            self.parse_comma_separated(|parser| {
-                                let expr = parser.parse_expr()?;
-                                let alias = parser.maybe_parse_select_item_alias()?;
-                                Ok(ExprWithAlias { expr, alias })
-                            })?
-                        } else {
-                            vec![]
-                        };
-                        pipe_operators.push(PipeOperator::Aggregate {
-                            full_table_exprs,
-                            group_by_exprs,
-                        })
-                    }
-                    Keyword::ORDER => {
-                        self.expect_one_of_keywords(&[Keyword::BY])?;
-                        let exprs = self.parse_comma_separated(Parser::parse_order_by_expr)?;
-                        pipe_operators.push(PipeOperator::OrderBy { exprs })
-                    }
-                    _ => {}
-                }
-            }
+            let pipe_operators = self.parse_pipe_operators()?;
 
             Ok(Query {
                 with,
@@ -10421,6 +10341,90 @@ impl<'a> Parser<'a> {
         }
     }
 
+    fn parse_pipe_operators(&mut self) -> Result<Vec<PipeOperator>, ParserError> {
+        let mut pipe_operators = Vec::new();
+
+        while self.consume_token(&Token::VerticalBarRightAngleBracket) {
+            let kw = self.expect_one_of_keywords(&[
+                Keyword::SELECT,
+                Keyword::EXTEND,
+                Keyword::SET,
+                Keyword::DROP,
+                Keyword::AS,
+                Keyword::WHERE,
+                Keyword::LIMIT,
+                Keyword::AGGREGATE,
+                Keyword::ORDER,
+            ])?;
+            match kw {
+                Keyword::SELECT => {
+                    let exprs = self.parse_comma_separated(Parser::parse_select_item)?;
+                    pipe_operators.push(PipeOperator::Select { exprs })
+                }
+                Keyword::EXTEND => {
+                    let exprs = self.parse_comma_separated(Parser::parse_select_item)?;
+                    pipe_operators.push(PipeOperator::Extend { exprs })
+                }
+                Keyword::SET => {
+                    let assignments = self.parse_comma_separated(Parser::parse_assignment)?;
+                    pipe_operators.push(PipeOperator::Set { assignments })
+                }
+                Keyword::DROP => {
+                    let columns = self.parse_identifiers()?;
+                    pipe_operators.push(PipeOperator::Drop { columns })
+                }
+                Keyword::AS => {
+                    let alias = self.parse_identifier()?;
+                    pipe_operators.push(PipeOperator::As { alias })
+                }
+                Keyword::WHERE => {
+                    let expr = self.parse_expr()?;
+                    pipe_operators.push(PipeOperator::Where { expr })
+                }
+                Keyword::LIMIT => {
+                    let expr = self.parse_expr()?;
+                    let offset = if self.parse_keyword(Keyword::OFFSET) {
+                        Some(self.parse_expr()?)
+                    } else {
+                        None
+                    };
+                    pipe_operators.push(PipeOperator::Limit { expr, offset })
+                }
+                Keyword::AGGREGATE => {
+                    let full_table_exprs = self.parse_comma_separated0(
+                        |parser| {
+                            let expr = parser.parse_expr()?;
+                            let alias = parser.maybe_parse_select_item_alias()?;
+                            Ok(ExprWithAlias { expr, alias })
+                        },
+                        Token::make_keyword(keywords::GROUP),
+                    )?;
+
+                    let group_by_exprs = if self.parse_keywords(&[Keyword::GROUP, Keyword::BY]) {
+                        self.parse_comma_separated(|parser| {
+                            let expr = parser.parse_expr()?;
+                            let alias = parser.maybe_parse_select_item_alias()?;
+                            Ok(ExprWithAlias { expr, alias })
+                        })?
+                    } else {
+                        vec![]
+                    };
+                    pipe_operators.push(PipeOperator::Aggregate {
+                        full_table_exprs,
+                        group_by_exprs,
+                    })
+                }
+                Keyword::ORDER => {
+                    self.expect_one_of_keywords(&[Keyword::BY])?;
+                    let exprs = self.parse_comma_separated(Parser::parse_order_by_expr)?;
+                    pipe_operators.push(PipeOperator::OrderBy { exprs })
+                }
+                _ => {}
+            }
+        }
+        Ok(pipe_operators)
+    }
+
     fn parse_settings(&mut self) -> Result<Option<Vec<Setting>>, ParserError> {
         let settings = if dialect_of!(self is ClickHouseDialect|GenericDialect)
             && self.parse_keyword(Keyword::SETTINGS)