unpivot

Author: simonvandel

src/ast/query.rs

@@ -2734,6 +2734,20 @@ pub enum PipeOperator {
         value_source: PivotValueSource,
         alias: Option<Ident>,
     },
+    /// The `UNPIVOT` pipe operator transforms columns into rows.
+    ///
+    /// Syntax:
+    /// ```sql
+    /// |> UNPIVOT(value_column FOR name_column IN (column1, column2, ...)) [alias]
+    /// ```
+    ///
+    /// See more at <https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#unpivot_pipe_operator>
+    Unpivot {
+        value_column: Ident,
+        name_column: Ident,
+        unpivot_columns: Vec<Ident>,
+        alias: Option<Ident>,
+    },
 }
 
 impl fmt::Display for PipeOperator {
@@ -2883,6 +2897,24 @@ impl fmt::Display for PipeOperator {
                 }
                 Ok(())
             }
+            PipeOperator::Unpivot {
+                value_column,
+                name_column,
+                unpivot_columns,
+                alias,
+            } => {
+                write!(
+                    f,
+                    "UNPIVOT({} FOR {} IN ({}))",
+                    value_column,
+                    name_column,
+                    display_comma_separated(unpivot_columns)
+                )?;
+                if let Some(alias) = alias {
+                    write!(f, " AS {}", alias)?;
+                }
+                Ok(())
+            }
         }
     }
 }

src/parser/mod.rs

@@ -11089,6 +11089,7 @@ impl<'a> Parser<'a> {
                 Keyword::EXCEPT,
                 Keyword::CALL,
                 Keyword::PIVOT,
+                Keyword::UNPIVOT,
             ])?;
             match kw {
                 Keyword::SELECT => {
@@ -11277,6 +11278,51 @@ impl<'a> Parser<'a> {
                         alias,
                     });
                 }
+                Keyword::UNPIVOT => {
+                    // Parse UNPIVOT(value_column FOR name_column IN (column1, column2, ...)) [alias]
+                    self.expect_token(&Token::LParen)?;
+                    
+                    // Parse value_column
+                    let value_column = self.parse_identifier()?;
+                    
+                    // Parse FOR keyword
+                    self.expect_keyword(Keyword::FOR)?;
+                    
+                    // Parse name_column
+                    let name_column = self.parse_identifier()?;
+                    
+                    // Parse IN keyword
+                    self.expect_keyword(Keyword::IN)?;
+                    
+                    // Parse (column1, column2, ...)
+                    self.expect_token(&Token::LParen)?;
+                    let unpivot_columns = self.parse_comma_separated(Parser::parse_identifier)?;
+                    self.expect_token(&Token::RParen)?;
+                    
+                    self.expect_token(&Token::RParen)?;
+
+                    // Parse optional alias (with or without AS keyword)
+                    let alias = if self.parse_keyword(Keyword::AS) {
+                        Some(self.parse_identifier()?)
+                    } else {
+                        // Check if the next token is an identifier (implicit alias)
+                        let checkpoint = self.index;
+                        match self.parse_identifier() {
+                            Ok(ident) => Some(ident),
+                            Err(_) => {
+                                self.index = checkpoint; // Rewind on failure
+                                None
+                            }
+                        }
+                    };
+
+                    pipe_operators.push(PipeOperator::Unpivot {
+                        value_column,
+                        name_column,
+                        unpivot_columns,
+                        alias,
+                    });
+                }
                 unhandled => {
                     return Err(ParserError::ParserError(format!(
                     "`expect_one_of_keywords` further up allowed unhandled keyword: {unhandled:?}"

tests/sqlparser_common.rs

@@ -15297,6 +15297,33 @@ fn parse_pipeline_operator() {
         "SELECT * FROM data |> PIVOT(AVG(price) FOR category IN ('A', 'B', 'C')) AS avg_by_category",
     );
 
+    // unpivot pipe operator basic usage
+    dialects.verified_stmt("SELECT * FROM sales |> UNPIVOT(revenue FOR quarter IN (Q1, Q2, Q3, Q4))");
+    dialects.verified_stmt("SELECT * FROM data |> UNPIVOT(value FOR category IN (A, B, C))");
+    dialects.verified_stmt("SELECT * FROM metrics |> UNPIVOT(measurement FOR metric_type IN (cpu, memory, disk))");
+    
+    // unpivot pipe operator with multiple columns
+    dialects.verified_stmt("SELECT * FROM quarterly_sales |> UNPIVOT(amount FOR period IN (jan, feb, mar, apr, may, jun))");
+    dialects.verified_stmt("SELECT * FROM report |> UNPIVOT(score FOR subject IN (math, science, english, history))");
+    
+    // unpivot pipe operator mixed with other pipe operators
+    dialects.verified_stmt("SELECT * FROM sales_data |> WHERE year = 2023 |> UNPIVOT(revenue FOR quarter IN (Q1, Q2, Q3, Q4))");
+    
+    // unpivot pipe operator with aliases
+    dialects.verified_stmt("SELECT * FROM quarterly_sales |> UNPIVOT(amount FOR period IN (Q1, Q2)) AS unpivoted_sales");
+    dialects.verified_stmt("SELECT * FROM data |> UNPIVOT(value FOR category IN (A, B, C)) AS transformed_data");
+    dialects.verified_stmt("SELECT * FROM metrics |> UNPIVOT(measurement FOR metric_type IN (cpu, memory)) AS metric_measurements");
+    
+    // unpivot pipe operator with implicit aliases (without AS keyword)
+    dialects.verified_query_with_canonical(
+        "SELECT * FROM quarterly_sales |> UNPIVOT(amount FOR period IN (Q1, Q2)) unpivoted_sales",
+        "SELECT * FROM quarterly_sales |> UNPIVOT(amount FOR period IN (Q1, Q2)) AS unpivoted_sales",
+    );
+    dialects.verified_query_with_canonical(
+        "SELECT * FROM data |> UNPIVOT(value FOR category IN (A, B, C)) transformed_data",
+        "SELECT * FROM data |> UNPIVOT(value FOR category IN (A, B, C)) AS transformed_data",
+    );
+
     // many pipes
     dialects.verified_stmt(
         "SELECT * FROM CustomerOrders |> AGGREGATE SUM(cost) AS total_cost GROUP BY customer_id, state, item_type |> EXTEND COUNT(*) OVER (PARTITION BY customer_id) AS num_orders |> WHERE num_orders > 1 |> AGGREGATE AVG(total_cost) AS average GROUP BY state DESC, item_type ASC",
@@ -15404,6 +15431,48 @@ fn parse_pipeline_operator_negative_tests() {
     assert!(
         dialects.parse_sql_statements("SELECT * FROM users |> PIVOT(SUM(amount) FOR month IN ('Jan')) AS").is_err()
     );
+
+    // Test UNPIVOT negative cases
+    
+    // Test that UNPIVOT without parentheses fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT value FOR name IN col1, col2").is_err()
+    );
+
+    // Test that UNPIVOT without FOR keyword fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT(value name IN (col1, col2))").is_err()
+    );
+
+    // Test that UNPIVOT without IN keyword fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name (col1, col2))").is_err()
+    );
+
+    // Test that UNPIVOT with missing value column fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT(FOR name IN (col1, col2))").is_err()
+    );
+
+    // Test that UNPIVOT with missing name column fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR IN (col1, col2))").is_err()
+    );
+
+    // Test that UNPIVOT with empty IN list fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name IN ())").is_err()
+    );
+
+    // Test that UNPIVOT with invalid alias syntax fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name IN (col1, col2)) AS").is_err()
+    );
+
+    // Test that UNPIVOT with missing closing parenthesis fails
+    assert!(
+        dialects.parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name IN (col1, col2)").is_err()
+    );
 }
 
 #[test]