Add CASE and IF statement support

Add support for scripting statements
```sql
CASE product_id
  WHEN 1 THEN SELECT 1;
  WHEN 2 THEN SELECT 2;
  ELSE SELECT 3;
END CASE;
```

```sql
IF EXISTS(SELECT 1) THEN SELECT 1;
  ELSEIF EXISTS(SELECT 2) THEN SELECT 2;
  ELSE SELECT 3;
END IF;
```

[BigQuery CASE](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#case)

[BigQuery IF](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#if)

[Snowflake CASE](https://docs.snowflake.com/en/sql-reference/snowflake-scripting/case)
[Snowflake IF](https://docs.snowflake.com/en/sql-reference/snowflake-scripting/if)

Author: iffyio

src/ast/mod.rs

@@ -149,6 +149,15 @@ where
     DisplaySeparated { slice, sep: ", " }
 }
 
+/// Writes the given statements to the formatter, each ending with
+/// a semicolon and space separated.
+fn format_statement_list(f: &mut fmt::Formatter, statements: &[Statement]) -> fmt::Result {
+    write!(f, "{}", display_separated(statements, "; "))?;
+    // We manually insert semicolon for the last statement,
+    // since display_separated doesn't handle that case.
+    write!(f, ";")
+}
+
 /// An identifier, decomposed into its value or character data and the quote style.
 #[derive(Debug, Clone, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -2070,6 +2079,173 @@ pub enum Password {
     NullPassword,
 }
 
+/// A `CASE` statement.
+///
+/// Examples:
+/// ```sql
+/// CASE
+///     WHEN EXISTS(SELECT 1)
+///         THEN SELECT 1 FROM T;
+///     WHEN EXISTS(SELECT 2)
+///         THEN SELECT 1 FROM U;
+///     ELSE
+///         SELECT 1 FROM V;
+/// END CASE;
+/// ```
+///
+/// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#case_search_expression)
+/// [Snowflake](https://docs.snowflake.com/en/sql-reference/snowflake-scripting/case)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CaseStatement {
+    pub match_expr: Option<Expr>,
+    pub when_blocks: Vec<ConditionalStatements>,
+    pub else_block: Option<Vec<Statement>>,
+    /// TRUE if the statement ends with `END CASE` (vs `END`).
+    pub has_end_case: bool,
+}
+
+impl fmt::Display for CaseStatement {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let CaseStatement {
+            match_expr,
+            when_blocks,
+            else_block,
+            has_end_case,
+        } = self;
+
+        write!(f, "CASE")?;
+
+        if let Some(expr) = match_expr {
+            write!(f, " {expr}")?;
+        }
+
+        if !when_blocks.is_empty() {
+            write!(f, " {}", display_separated(when_blocks, " "))?;
+        }
+
+        if let Some(else_block) = else_block {
+            write!(f, " ELSE ")?;
+            format_statement_list(f, else_block)?;
+        }
+
+        write!(f, " END")?;
+        if *has_end_case {
+            write!(f, " CASE")?;
+        }
+
+        Ok(())
+    }
+}
+
+/// An `IF` statement.
+///
+/// Examples:
+/// ```sql
+/// IF TRUE THEN
+///     SELECT 1;
+///     SELECT 2;
+/// ELSEIF TRUE THEN
+///     SELECT 3;
+/// ELSE
+///     SELECT 4;
+/// END IF
+/// ```
+///
+/// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#if)
+/// [Snowflake](https://docs.snowflake.com/en/sql-reference/snowflake-scripting/if)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IfStatement {
+    pub if_block: ConditionalStatements,
+    pub elseif_blocks: Vec<ConditionalStatements>,
+    pub else_block: Option<Vec<Statement>>,
+}
+
+impl fmt::Display for IfStatement {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let IfStatement {
+            if_block,
+            elseif_blocks,
+            else_block,
+        } = self;
+
+        write!(f, "{if_block}")?;
+
+        if !elseif_blocks.is_empty() {
+            write!(f, " {}", display_separated(elseif_blocks, " "))?;
+        }
+
+        if let Some(else_block) = else_block {
+            write!(f, " ELSE ")?;
+            format_statement_list(f, else_block)?;
+        }
+
+        write!(f, " END IF")?;
+
+        Ok(())
+    }
+}
+
+/// Represents a type of [ConditionalStatements]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ConditionalStatementKind {
+    /// `WHEN <condition> THEN <statements>
+    When,
+    /// `IF <condition> THEN <statements>
+    If,
+    /// `ELSEIF <condition> THEN <statements>
+    ElseIf,
+}
+
+/// A block within a [Statement::Case] or [Statement::If]-like statement
+///
+/// Examples:
+/// ```sql
+/// WHEN EXISTS(SELECT 1) THEN SELECT 1;
+///
+/// IF TRUE THEN SELECT 1; SELECT 2;
+/// ```
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ConditionalStatements {
+    /// The condition expression.
+    pub condition: Expr,
+    /// Statement list of the `THEN` clause.
+    pub statements: Vec<Statement>,
+    pub kind: ConditionalStatementKind,
+}
+
+impl fmt::Display for ConditionalStatements {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let ConditionalStatements {
+            condition: expr,
+            statements,
+            kind,
+        } = self;
+
+        let kind = match kind {
+            ConditionalStatementKind::When => "WHEN",
+            ConditionalStatementKind::If => "IF",
+            ConditionalStatementKind::ElseIf => "ELSEIF",
+        };
+
+        write!(f, "{kind} {expr} THEN")?;
+
+        if !statements.is_empty() {
+            write!(f, " ")?;
+            format_statement_list(f, statements)?;
+        }
+
+        Ok(())
+    }
+}
+
 /// Represents an expression assignment within a variable `DECLARE` statement.
 ///
 /// Examples:
@@ -2474,6 +2650,10 @@ pub enum Statement {
         file_format: Option<FileFormat>,
         source: Box<Query>,
     },
+    /// A `CASE` statement.
+    Case(CaseStatement),
+    /// An `IF` statement.
+    If(IfStatement),
     /// ```sql
     /// CALL <function>
     /// ```
@@ -3805,6 +3985,12 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::Case(stmt) => {
+                write!(f, "{stmt}")
+            }
+            Statement::If(stmt) => {
+                write!(f, "{stmt}")
+            }
             Statement::AttachDatabase {
                 schema_name,
                 database_file_name,
@@ -4857,18 +5043,14 @@ impl fmt::Display for Statement {
                     write!(f, " {}", display_comma_separated(modes))?;
                 }
                 if !statements.is_empty() {
-                    write!(f, " {}", display_separated(statements, "; "))?;
-                    // We manually insert semicolon for the last statement,
-                    // since display_separated doesn't handle that case.
-                    write!(f, ";")?;
+                    write!(f, " ")?;
+                    format_statement_list(f, statements)?;
                 }
                 if let Some(exception_statements) = exception_statements {
                     write!(f, " EXCEPTION WHEN ERROR THEN")?;
                     if !exception_statements.is_empty() {
-                        write!(f, " {}", display_separated(exception_statements, "; "))?;
-                        // We manually insert semicolon for the last statement,
-                        // since display_separated doesn't handle that case.
-                        write!(f, ";")?;
+                        write!(f, " ")?;
+                        format_statement_list(f, exception_statements)?;
                     }
                 }
                 if *has_end_keyword {

src/ast/spans.rs

@@ -22,19 +22,20 @@ use crate::tokenizer::Span;
 
 use super::{
     dcl::SecondaryRoles, AccessExpr, AlterColumnOperation, AlterIndexOperation,
-    AlterTableOperation, Array, Assignment, AssignmentTarget, CloseCursor, ClusteredIndex,
-    ColumnDef, ColumnOption, ColumnOptionDef, ConflictTarget, ConnectBy, ConstraintCharacteristics,
-    CopySource, CreateIndex, CreateTable, CreateTableOptions, Cte, Delete, DoUpdate,
-    ExceptSelectItem, ExcludeSelectItem, Expr, ExprWithAlias, Fetch, FromTable, Function,
-    FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList, FunctionArguments,
-    GroupByExpr, HavingBound, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join,
-    JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, MatchRecognizePattern,
-    Measure, NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict,
-    OnConflictAction, OnInsert, OrderBy, OrderByExpr, OrderByKind, Partition, PivotValueSource,
-    ProjectionSelect, Query, ReferentialAction, RenameSelectItem, ReplaceSelectElement,
-    ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript,
-    SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint, TableFactor, TableObject,
-    TableOptionsClustered, TableWithJoins, UpdateTableFromKind, Use, Value, Values, ViewColumnDef,
+    AlterTableOperation, Array, Assignment, AssignmentTarget, CaseStatement, CloseCursor,
+    ClusteredIndex, ColumnDef, ColumnOption, ColumnOptionDef, ConditionalStatements,
+    ConflictTarget, ConnectBy, ConstraintCharacteristics, CopySource, CreateIndex, CreateTable,
+    CreateTableOptions, Cte, Delete, DoUpdate, ExceptSelectItem, ExcludeSelectItem, Expr,
+    ExprWithAlias, Fetch, FromTable, Function, FunctionArg, FunctionArgExpr,
+    FunctionArgumentClause, FunctionArgumentList, FunctionArguments, GroupByExpr, HavingBound,
+    IfStatement, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join, JoinConstraint,
+    JoinOperator, JsonPath, JsonPathElem, LateralView, MatchRecognizePattern, Measure,
+    NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict, OnConflictAction,
+    OnInsert, OrderBy, OrderByExpr, OrderByKind, Partition, PivotValueSource, ProjectionSelect,
+    Query, ReferentialAction, RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select,
+    SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript, SymbolDefinition, TableAlias,
+    TableAliasColumnDef, TableConstraint, TableFactor, TableObject, TableOptionsClustered,
+    TableWithJoins, UpdateTableFromKind, Use, Value, Values, ViewColumnDef,
     WildcardAdditionalOptions, With, WithFill,
 };
 
@@ -323,6 +324,8 @@ impl Spanned for Statement {
                 file_format: _,
                 source,
             } => source.span(),
+            Statement::Case(stmt) => stmt.span(),
+            Statement::If(stmt) => stmt.span(),
             Statement::Call(function) => function.span(),
             Statement::Copy {
                 source,
@@ -728,6 +731,53 @@ impl Spanned for CreateIndex {
     }
 }
 
+impl Spanned for CaseStatement {
+    fn span(&self) -> Span {
+        let CaseStatement {
+            match_expr,
+            when_blocks,
+            else_block,
+            has_end_case: _,
+        } = self;
+
+        union_spans(
+            match_expr
+                .iter()
+                .map(|e| e.span())
+                .chain(when_blocks.iter().map(|b| b.span()))
+                .chain(else_block.iter().flat_map(|e| e.iter().map(|s| s.span()))),
+        )
+    }
+}
+
+impl Spanned for IfStatement {
+    fn span(&self) -> Span {
+        let IfStatement {
+            if_block,
+            elseif_blocks,
+            else_block,
+        } = self;
+
+        union_spans(
+            iter::once(if_block.span())
+                .chain(elseif_blocks.iter().map(|b| b.span()))
+                .chain(else_block.iter().flat_map(|e| e.iter().map(|s| s.span()))),
+        )
+    }
+}
+
+impl Spanned for ConditionalStatements {
+    fn span(&self) -> Span {
+        let ConditionalStatements {
+            condition,
+            statements,
+            kind: _,
+        } = self;
+
+        union_spans(iter::once(condition.span()).chain(statements.iter().map(|s| s.span())))
+    }
+}
+
 /// # partial span
 ///
 /// Missing spans:

src/keywords.rs

@@ -294,6 +294,7 @@ define_keywords!(
     ELEMENT,
     ELEMENTS,
     ELSE,
+    ELSEIF,
     EMPTY,
     ENABLE,
     ENABLE_SCHEMA_EVOLUTION,