better variant docs, rename Alias -> As

Author: simonvandel

src/ast/query.rs

@@ -2413,35 +2413,76 @@ impl fmt::Display for OffsetRows {
     }
 }
 
+/// Pipe syntax, first introduced in Google BigQuery.
+/// Example:
+///
+/// ```sql
+/// FROM Produce
+/// |> WHERE sales > 0
+/// |> AGGREGATE SUM(sales) AS total_sales, COUNT(*) AS num_sales
+///    GROUP BY item;
+/// ```
+///
+/// See https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#pipe_syntax
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum PipeOperator {
-    Limit {
-        expr: Expr,
-        offset: Option<Expr>,
-    },
-    Where {
-        expr: Expr,
-    },
-    OrderBy {
-        exprs: Vec<OrderByExpr>,
-    },
-    Select {
-        exprs: Vec<SelectItem>,
-    },
-    Extend {
-        exprs: Vec<SelectItem>,
-    },
-    Set {
-        assignments: Vec<Assignment>,
-    },
-    Drop {
-        columns: Vec<Ident>,
-    },
-    Alias {
-        alias: Ident,
-    },
+    /// Limits the number of rows to return in a query, with an optional OFFSET clause to skip over rows.
+    ///
+    /// Syntax: `|> LIMIT <n> [OFFSET <m>]`
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#limit_pipe_operator
+    Limit { expr: Expr, offset: Option<Expr> },
+    /// Filters the results of the input table.
+    ///
+    /// Syntax: `|> WHERE <condition>`
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#where_pipe_operator
+    Where { expr: Expr },
+    /// ORDER BY <expr> [ASC|DESC], ...
+    OrderBy { exprs: Vec<OrderByExpr> },
+    /// Produces a new table with the listed columns, similar to the outermost SELECT clause in a table subquery in standard syntax.
+    ///
+    /// Syntax `|> SELECT <expr> [[AS] alias], ...`
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#select_pipe_operator
+    Select { exprs: Vec<SelectItem> },
+    /// Propagates the existing table and adds computed columns, similar to SELECT *, new_column in standard syntax.
+    ///
+    /// Syntax: `|> EXTEND <expr> [[AS] alias], ...`
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#extend_pipe_operator
+    Extend { exprs: Vec<SelectItem> },
+    /// Replaces the value of a column in the current table, similar to SELECT * REPLACE (expression AS column) in standard syntax.
+    ///
+    /// Syntax: `|> SET <column> = <expression>, ...`
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#set_pipe_operator
+    Set { assignments: Vec<Assignment> },
+    /// Removes listed columns from the current table, similar to SELECT * EXCEPT (column) in standard syntax.
+    ///
+    /// Syntax: `|> DROP <column>, ...`
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#drop_pipe_operator
+    Drop { columns: Vec<Ident> },
+    /// Introduces a table alias for the input table, similar to applying the AS alias clause on a table subquery in standard syntax.
+    ///
+    /// Syntax: `|> AS <alias>`
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#as_pipe_operator
+    As { alias: Ident },
+    /// Performs aggregation on data across grouped rows or an entire table.
+    ///
+    /// Syntax: `|> AGGREGATE <agg_expr> [[AS] alias], ...`
+    ///
+    /// Syntax:
+    /// ```
+    /// |> AGGREGATE [<agg_expr> [[AS] alias], ...]
+    /// GROUP BY <grouping_expr> [AS alias], ...
+    /// ```
+    ///
+    /// See more at https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#aggregate_pipe_operator
     Aggregate {
         full_table_exprs: Vec<ExprWithAlias>,
         group_by_exprs: Vec<ExprWithAlias>,
@@ -2463,7 +2504,7 @@ impl fmt::Display for PipeOperator {
             PipeOperator::Drop { columns } => {
                 write!(f, "DROP {}", display_comma_separated(columns.as_slice()))
             }
-            PipeOperator::Alias { alias } => {
+            PipeOperator::As { alias } => {
                 write!(f, "AS {}", alias)
             }
             PipeOperator::Limit { expr, offset } => {

src/parser/mod.rs

@@ -10336,37 +10336,30 @@ impl<'a> Parser<'a> {
                     Keyword::ORDER,
                 ])?;
                 match kw {
-                    // SELECT <expr> [[AS] alias], ...
                     Keyword::SELECT => {
                         let exprs = self.parse_comma_separated(Parser::parse_select_item)?;
                         pipe_operators.push(PipeOperator::Select { exprs })
                     }
-                    // EXTEND <expr> [[AS] alias], ...
                     Keyword::EXTEND => {
                         let exprs = self.parse_comma_separated(Parser::parse_select_item)?;
                         pipe_operators.push(PipeOperator::Extend { exprs })
                     }
-                    // SET <column> = <expression>, ...
                     Keyword::SET => {
                         let assignments = self.parse_comma_separated(Parser::parse_assignment)?;
                         pipe_operators.push(PipeOperator::Set { assignments })
                     }
-                    // DROP <column>, ...
                     Keyword::DROP => {
                         let columns = self.parse_identifiers()?;
                         pipe_operators.push(PipeOperator::Drop { columns })
                     }
-                    // AS <alias>
                     Keyword::AS => {
                         let alias = self.parse_identifier()?;
-                        pipe_operators.push(PipeOperator::Alias { alias })
+                        pipe_operators.push(PipeOperator::As { alias })
                     }
-                    // WHERE <condition>
                     Keyword::WHERE => {
                         let expr = self.parse_expr()?;
                         pipe_operators.push(PipeOperator::Where { expr })
                     }
-                    // LIMIT <n> [OFFSET <m>]
                     Keyword::LIMIT => {
                         let expr = self.parse_expr()?;
                         let offset = if self.parse_keyword(Keyword::OFFSET) {
@@ -10376,12 +10369,6 @@ impl<'a> Parser<'a> {
                         };
                         pipe_operators.push(PipeOperator::Limit { expr, offset })
                     }
-                    // AGGREGATE <agg_expr> [[AS] alias], ...
-                    //
-                    // and
-                    //
-                    // AGGREGATE [<agg_expr> [[AS] alias], ...]
-                    // GROUP BY <grouping_expr> [AS alias], ...
                     Keyword::AGGREGATE => {
                         let full_table_exprs = self.parse_comma_separated0(
                             |parser| {
@@ -10407,7 +10394,6 @@ impl<'a> Parser<'a> {
                             group_by_exprs,
                         })
                     }
-                    // ORDER BY <expr> [ASC|DESC], ...
                     Keyword::ORDER => {
                         self.expect_one_of_keywords(&[Keyword::BY])?;
                         let exprs = self.parse_comma_separated(Parser::parse_order_by_expr)?;