sql_beautifier 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcf549a9025b3f1baa8e3e6586154ce0e4b9529985f8e54b49ff241e4a24cd19
-  data.tar.gz: ce6eb31a10ad63436442bf0a27d4054857540a03d2b799ecf40db46246ac0852
+  metadata.gz: 9557199079511cec5188c694dd32e2d114aaedebb896b90dc4ebe9e95308f116
+  data.tar.gz: da7fe2c4ff35032c6908a8ea10b5e8c4482cb607a78ac3c241b7d4f2093bbc88
 SHA512:
-  metadata.gz: f2bed68bdfff3e132819a44756f57da8b8e8445738d85e967ea98d108510afe4c2840f0f4a2ef592bf0cbbccac8facfaf247b31e2f8810c6e22d65c8ecee551d
-  data.tar.gz: 595b15be6f7f1a6b7541580d679ef0bde692bca70e4cffec251ea4f995aa3f54c17305b28b2a62ee0172ed40ca1137a013f4041d5ecf2624bcd22a7563a52672
+  metadata.gz: d363570c1c0add348461b8b9069eb4f7075036140f6c7b86f03130c88903f5fcf17613123841a28ca28b55eeb6b3f16905572017222904a58595586dbb782134
+  data.tar.gz: da33c33ada19314d1421d7a1cab384b9f6fa25b456909f2086b662bf8c235089443a8513b95049bbebe7db70d4535d32cefec664de3927a0d5ca7a0f9da10c87

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.10.0] - 2026-03-30
+
+- Add CASE expression formatting — searched CASE (`CASE WHEN ... THEN ... ELSE ... END`) and simple CASE (`CASE expr WHEN value THEN ... END`) are detected and formatted with consistent indentation of `when`/`else`/`end` lines relative to the `case` keyword
+- Add CASE integration into SELECT columns, WHERE/HAVING conditions, and UPDATE SET assignments via `CaseExpression.format_in_text`
+- Add inline vs expanded rendering for CASE expressions controlled by the existing `inline_group_threshold` configuration — short CASE expressions remain on a single line when below the threshold
+- Add nested CASE support — inner CASE blocks within WHEN/THEN/ELSE values are recursively formatted with increased indentation
+- Add string-literal and sentinel safety — CASE keywords inside quoted strings, double-quoted identifiers, and comment sentinels are not mistakenly parsed
+- Preserve CASE expressions inside parenthesized function calls (e.g. `COALESCE(CASE ... END, 0)`) without top-level expansion
+- Fix `AND`/`OR` inside CASE expressions being misidentified as top-level conjunctions in WHERE/HAVING clauses — conjunction scanning now tracks CASE/END depth
+- Use `indent_spaces` configuration for CASE body indentation instead of a hard-coded value
+- Add `INNER JOIN LATERAL` and `LEFT JOIN LATERAL` support — `LATERAL` is recognized as a join modifier rather than a table name, preserving correct derived table parsing and alias resolution for lateral subqueries
+- Strip redundant outer parentheses from WHERE and HAVING clause bodies — `WHERE (active = true)`, `WHERE ((active = true))`, and `WHERE ((a = true) AND (b = true))` now correctly unwrap before formatting
+- Fix `Condition.format` early return for single leaf conditions to use the unwrapped expression instead of the original text
+
 ## [0.9.2] - 2026-03-30
 
 - Fix derived tables (subqueries in `FROM` clauses) losing their content during formatting — `TableRegistry#parse_references` used a regex split that did not respect parenthesis depth, causing JOIN keywords inside derived table subqueries to be treated as top-level boundaries

data/README.md

@@ -111,7 +111,7 @@ where   u.active = true
 order by o.total desc;
 ```
 
-Supported join types: `inner join`, `left join`, `right join`, `full join`, `left outer join`, `right outer join`, `full outer join`, `cross join`.
+Supported join types: `inner join`, `left join`, `right join`, `full join`, `left outer join`, `right outer join`, `full outer join`, `cross join`. The `LATERAL` modifier is supported with `inner join lateral` and `left join lateral` for lateral subqueries.
 
 ### DISTINCT and DISTINCT ON
 
@@ -212,6 +212,61 @@ group by status
 having  count(*) > 5;
 ```
 
+### CASE Expressions
+
+Both searched (`CASE WHEN ... THEN ... END`) and simple (`CASE expr WHEN value THEN ... END`) forms are formatted with multiline indentation. Inner `when`/`else`/`end` lines are indented relative to the `case` keyword:
+
+```ruby
+SqlBeautifier.call("SELECT id, CASE WHEN status = 'active' THEN 'Active' WHEN status = 'pending' THEN 'Pending' ELSE 'Unknown' END AS status_label, name FROM users")
+```
+
+Produces:
+
+```sql
+select  id,
+        case
+            when status = 'active' then 'Active'
+            when status = 'pending' then 'Pending'
+            else 'Unknown'
+        end as status_label,
+        name
+
+from    Users u;
+```
+
+Simple CASE places the operand on the `case` line:
+
+```ruby
+SqlBeautifier.call("SELECT CASE u.role WHEN 'admin' THEN 'Administrator' WHEN 'user' THEN 'Standard User' ELSE 'Guest' END AS role_label FROM users")
+```
+
+Produces:
+
+```sql
+select  case u.role
+            when 'admin' then 'Administrator'
+            when 'user' then 'Standard User'
+            else 'Guest'
+        end as role_label
+
+from    Users u;
+```
+
+CASE expressions inside parenthesized function calls are preserved inline:
+
+```ruby
+SqlBeautifier.call("SELECT COALESCE(CASE WHEN x > 0 THEN x ELSE NULL END, 0) AS safe_x FROM users")
+```
+
+Produces:
+
+```sql
+select  coalesce(case when x > 0 then x else null end, 0) as safe_x
+from    Users u;
+```
+
+CASE expressions also work in WHERE/HAVING conditions and UPDATE SET assignments. Nested CASE blocks are recursively formatted with increased indentation. Short CASE expressions can remain inline when below the `inline_group_threshold`.
+
 ### LIMIT
 
 ```ruby
@@ -616,9 +671,9 @@ Controls how table names are formatted in the output. Default: `:pascal_case`.
 
 #### `inline_group_threshold`
 
-Maximum character length for a parenthesized condition group to remain on a single line. Groups whose inline representation exceeds this length are expanded to multiple lines with indented conditions. Default: `0` (always expand).
+Maximum character length for a parenthesized condition group or CASE expression to remain on a single line. Groups and CASE expressions whose inline representation exceeds this length are expanded to multiple lines with indented contents. Default: `0` (always expand).
 
-Set to a positive integer to allow short groups to stay inline. For example, with a threshold of `80`, the group `(role = 'admin' or role = 'moderator')` would stay on one line since it's under 80 characters.
+Set to a positive integer to allow short groups and CASE expressions to stay inline. For example, with a threshold of `80`, the group `(role = 'admin' or role = 'moderator')` and a short CASE like `case when x = 1 then 'yes' else 'no' end` would stay on one line since they're under 80 characters.
 
 #### `trailing_semicolon`
 

data/lib/sql_beautifier/case_expression.rb

@@ -0,0 +1,405 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class CaseExpression < Base
+    CASE_KEYWORD = "case"
+    WHEN_KEYWORD = "when"
+    THEN_KEYWORD = "then"
+    ELSE_KEYWORD = "else"
+    END_KEYWORD = "end"
+
+    option :operand, default: -> {}
+    option :when_clauses
+    option :else_value, default: -> {}
+    option :base_indent, default: -> { 0 }
+
+    def self.format_in_text(text, base_indent: 0)
+      output = +""
+      scanner = Scanner.new(text)
+
+      while scanner.position < text.length
+        consumed = scanner.scan_quoted_or_sentinel!
+        if consumed
+          output << consumed
+          next
+        end
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          output << scanner.current_char
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          output << scanner.current_char
+          scanner.advance!
+          next
+        end
+
+        if scanner.parenthesis_depth.zero? && scanner.keyword_at?(CASE_KEYWORD)
+          case_start = scanner.position
+          end_position = find_matching_end(text, case_start)
+
+          unless end_position
+            output << scanner.current_char
+            scanner.advance!
+            next
+          end
+
+          case_text = text[case_start...(end_position + END_KEYWORD.length)]
+          parsed = parse(case_text, base_indent: base_indent)
+          output << (parsed ? parsed.render : case_text)
+
+          scanner.advance!(end_position + END_KEYWORD.length - scanner.position)
+          next
+        end
+
+        output << scanner.current_char
+        scanner.advance!
+      end
+
+      output
+    end
+
+    def self.parse(text, base_indent: 0)
+      stripped = text.strip
+      scanner = Scanner.new(stripped)
+      return nil unless scanner.keyword_at?(CASE_KEYWORD)
+
+      scanner.skip_past_keyword!(CASE_KEYWORD)
+
+      operand = extract_operand(stripped, scanner)
+      when_clauses = []
+      else_value = nil
+      case_depth = 1
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.parenthesis_depth.zero?
+          if scanner.keyword_at?(CASE_KEYWORD)
+            case_depth += 1
+            scanner.advance!(CASE_KEYWORD.length)
+            next
+          end
+
+          if scanner.keyword_at?(END_KEYWORD)
+            case_depth -= 1
+
+            if case_depth.zero?
+              return new(
+                operand: operand,
+                when_clauses: when_clauses,
+                else_value: else_value,
+                base_indent: base_indent
+              )
+            end
+
+            scanner.advance!(END_KEYWORD.length)
+            next
+          end
+
+          if case_depth == 1
+            if scanner.keyword_at?(WHEN_KEYWORD)
+              parsed_clause = parse_when_clause(stripped, scanner)
+              return nil unless parsed_clause
+
+              when_clauses << parsed_clause
+              next
+            end
+
+            if scanner.keyword_at?(ELSE_KEYWORD)
+              else_value = parse_else_value(stripped, scanner)
+              next
+            end
+          end
+        end
+
+        scanner.advance!
+      end
+
+      nil
+    end
+
+    def render
+      inline_version = render_inline
+      threshold = SqlBeautifier.config_for(:inline_group_threshold)
+
+      return inline_version if inline_version.length <= threshold
+
+      render_expanded
+    end
+
+    private
+
+    def render_inline
+      parts = +"case"
+      parts << " #{@operand}" if @operand
+
+      @when_clauses.each do |clause|
+        parts << " when #{clause[:condition]} then #{clause[:result]}"
+      end
+
+      parts << " else #{@else_value}" if @else_value
+      parts << " end"
+
+      parts
+    end
+
+    def render_expanded
+      indent_spaces = SqlBeautifier.config_for(:indent_spaces)
+      body_indent = Util.whitespace(@base_indent + indent_spaces)
+      closing_indent = Util.whitespace(@base_indent)
+      nested_base_indent = @base_indent + indent_spaces
+
+      lines = []
+
+      case_line = +"case"
+      case_line << " #{@operand}" if @operand
+      lines << case_line
+
+      @when_clauses.each do |clause|
+        formatted_condition = CaseExpression.format_in_text(clause[:condition], base_indent: nested_base_indent)
+        formatted_result = CaseExpression.format_in_text(clause[:result], base_indent: nested_base_indent)
+        lines << "#{body_indent}when #{formatted_condition} then #{formatted_result}"
+      end
+
+      if @else_value
+        formatted_else = CaseExpression.format_in_text(@else_value, base_indent: nested_base_indent)
+        lines << "#{body_indent}else #{formatted_else}"
+      end
+
+      lines << "#{closing_indent}end"
+
+      lines.join("\n")
+    end
+
+    def self.extract_operand(text, scanner)
+      start_position = scanner.position
+      operand_scanner = Scanner.new(text, position: start_position)
+
+      until operand_scanner.finished?
+        consumed = operand_scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        if operand_scanner.current_char == Constants::OPEN_PARENTHESIS
+          operand_scanner.increment_depth!
+          operand_scanner.advance!
+          next
+        end
+
+        if operand_scanner.current_char == Constants::CLOSE_PARENTHESIS
+          operand_scanner.decrement_depth!
+          operand_scanner.advance!
+          next
+        end
+
+        if operand_scanner.parenthesis_depth.zero? && operand_scanner.keyword_at?(WHEN_KEYWORD)
+          operand_text = text[start_position...operand_scanner.position].strip
+          scanner.advance!(operand_scanner.position - scanner.position)
+
+          return operand_text.empty? ? nil : operand_text
+        end
+
+        operand_scanner.advance!
+      end
+
+      scanner.advance!(operand_scanner.position - scanner.position)
+      nil
+    end
+
+    def self.parse_when_clause(text, scanner)
+      scanner.skip_past_keyword!(WHEN_KEYWORD)
+      condition_start = scanner.position
+      case_depth = 0
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.parenthesis_depth.zero?
+          if scanner.keyword_at?(CASE_KEYWORD)
+            case_depth += 1
+            scanner.advance!(CASE_KEYWORD.length)
+            next
+          end
+
+          if scanner.keyword_at?(END_KEYWORD) && case_depth.positive?
+            case_depth -= 1
+            scanner.advance!(END_KEYWORD.length)
+            next
+          end
+
+          if case_depth.zero? && scanner.keyword_at?(THEN_KEYWORD)
+            condition = text[condition_start...scanner.position].strip
+            scanner.skip_past_keyword!(THEN_KEYWORD)
+            then_result = parse_then_result(text, scanner)
+
+            return { condition: condition, result: then_result }
+          end
+        end
+
+        scanner.advance!
+      end
+
+      nil
+    end
+
+    def self.parse_then_result(text, scanner)
+      result_start = scanner.position
+      case_depth = 0
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.parenthesis_depth.zero?
+          if scanner.keyword_at?(CASE_KEYWORD)
+            case_depth += 1
+            scanner.advance!(CASE_KEYWORD.length)
+            next
+          end
+
+          if scanner.keyword_at?(END_KEYWORD) && case_depth.positive?
+            case_depth -= 1
+            scanner.advance!(END_KEYWORD.length)
+            next
+          end
+
+          return text[result_start...scanner.position].strip if case_depth.zero? && (scanner.keyword_at?(WHEN_KEYWORD) || scanner.keyword_at?(ELSE_KEYWORD) || scanner.keyword_at?(END_KEYWORD))
+        end
+
+        scanner.advance!
+      end
+
+      text[result_start...scanner.position].strip
+    end
+
+    def self.parse_else_value(text, scanner)
+      scanner.skip_past_keyword!(ELSE_KEYWORD)
+      else_start = scanner.position
+      case_depth = 0
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.parenthesis_depth.zero?
+          if scanner.keyword_at?(CASE_KEYWORD)
+            case_depth += 1
+            scanner.advance!(CASE_KEYWORD.length)
+            next
+          end
+
+          if scanner.keyword_at?(END_KEYWORD) && case_depth.positive?
+            case_depth -= 1
+            scanner.advance!(END_KEYWORD.length)
+            next
+          end
+
+          return text[else_start...scanner.position].strip if case_depth.zero? && scanner.keyword_at?(END_KEYWORD)
+        end
+
+        scanner.advance!
+      end
+
+      text[else_start...scanner.position].strip
+    end
+
+    def self.find_matching_end(text, case_start)
+      scanner = Scanner.new(text, position: case_start)
+      scanner.advance!(CASE_KEYWORD.length)
+      case_depth = 1
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.parenthesis_depth.zero?
+          if scanner.keyword_at?(CASE_KEYWORD)
+            case_depth += 1
+            scanner.advance!(CASE_KEYWORD.length)
+            next
+          end
+
+          if scanner.keyword_at?(END_KEYWORD)
+            case_depth -= 1
+            return scanner.position if case_depth.zero?
+
+            scanner.advance!(END_KEYWORD.length)
+            next
+          end
+        end
+
+        scanner.advance!
+      end
+
+      nil
+    end
+
+    private_class_method :extract_operand, :parse_when_clause, :parse_then_result, :parse_else_value, :find_matching_end
+  end
+end

data/lib/sql_beautifier/clauses/condition_clause.rb

@@ -4,16 +4,26 @@ module SqlBeautifier
   module Clauses
     class ConditionClause < Base
       def call
-        return "#{keyword_prefix}#{@value.strip}" unless multiple_conditions?
+        keyword_width = SqlBeautifier.config_for(:keyword_column_width)
+        formatted_value = CaseExpression.format_in_text(@value, base_indent: keyword_width)
+        unwrapped_value = strip_wrapping_parentheses(formatted_value)
 
-        formatted_conditions = Condition.format(@value, indent_width: SqlBeautifier.config_for(:keyword_column_width))
+        return "#{keyword_prefix}#{unwrapped_value}" unless multiple_conditions?(unwrapped_value)
+
+        formatted_conditions = Condition.format(unwrapped_value, indent_width: keyword_width)
         formatted_conditions.sub(continuation_indent, keyword_prefix)
       end
 
       private
 
-      def multiple_conditions?
-        Tokenizer.split_top_level_conditions(@value).length > 1
+      def strip_wrapping_parentheses(text)
+        output = text.strip
+        output = Util.strip_outer_parentheses(output) while Tokenizer.outer_parentheses_wrap_all?(output)
+        output
+      end
+
+      def multiple_conditions?(text)
+        Tokenizer.split_top_level_conditions(text).length > 1
       end
     end
   end

data/lib/sql_beautifier/clauses/select.rb

@@ -21,8 +21,11 @@ module SqlBeautifier
       private
 
       def parse_expressions(value)
+        keyword_width = SqlBeautifier.config_for(:keyword_column_width)
+
         Tokenizer.split_by_top_level_commas(value).map do |column|
-          Expression.parse(column)
+          formatted_column = CaseExpression.format_in_text(column, base_indent: keyword_width)
+          Expression.parse(formatted_column)
         end
       end
 

data/lib/sql_beautifier/condition.rb

@@ -8,7 +8,7 @@ module SqlBeautifier
 
     def self.format(text, indent_width: 0)
       conditions = parse_all(text)
-      return text.strip if conditions.length <= 1 && conditions.first&.leaf?
+      return conditions.first.expression if conditions.length <= 1 && conditions.first&.leaf?
 
       render_all(conditions, indent_width: indent_width)
     end

data/lib/sql_beautifier/constants.rb

@@ -42,6 +42,8 @@ module SqlBeautifier
     CLOSE_PARENTHESIS = ")"
     COMMA = ","
 
+    LATERAL_PREFIX_PATTERN = %r{\Alateral\s+}i
+
     WHITESPACE_REGEX = %r{\s+}
     WHITESPACE_CHARACTER_REGEX = %r{\s}
     SINGLE_QUOTE = "'"

data/lib/sql_beautifier/create_table_as.rb

@@ -2,7 +2,13 @@
 
 module SqlBeautifier
   class CreateTableAs < Base
-    MODIFIERS = %w[temp temporary unlogged local].freeze
+    MODIFIERS = %w[
+      temp
+      temporary
+      unlogged
+      local
+    ].freeze
+
     WITH_DATA_SUFFIX_REGEX = %r{\s+(with\s+(?:no\s+)?data)\s*\z}i
 
     option :modifier, default: -> {}

data/lib/sql_beautifier/join.rb

@@ -3,6 +3,7 @@
 module SqlBeautifier
   class Join < Base
     option :keyword
+    option :lateral, default: -> { false }
     option :table_reference
     option :trailing_sentinels, default: -> {}
     option :conditions, default: -> { [] }
@@ -11,6 +12,8 @@ module SqlBeautifier
       keyword, remaining_content = extract_keyword(join_text)
       return unless keyword && remaining_content
 
+      remaining_content, lateral = TableReference.strip_lateral_prefix(remaining_content)
+
       on_keyword_position = Tokenizer.find_top_level_keyword(remaining_content, "on")
 
       if on_keyword_position
@@ -28,7 +31,7 @@ module SqlBeautifier
 
       trailing_sentinels = extract_trailing_sentinels(table_text)
 
-      new(keyword: keyword, table_reference: table_reference, trailing_sentinels: trailing_sentinels, conditions: conditions)
+      new(keyword: keyword, lateral: lateral, table_reference: table_reference, trailing_sentinels: trailing_sentinels, conditions: conditions)
     end
 
     def self.extract_keyword(join_text)
@@ -52,17 +55,18 @@ module SqlBeautifier
 
     def render(continuation_indent:, condition_indent:)
       rendered_table = @table_reference.render(trailing_sentinels: @trailing_sentinels)
+      lateral_prefix = @lateral ? "lateral " : ""
       lines = []
 
       if @conditions.any?
         first_condition = @conditions.first[1]
-        lines << "#{continuation_indent}#{@keyword} #{rendered_table} on #{first_condition}"
+        lines << "#{continuation_indent}#{@keyword} #{lateral_prefix}#{rendered_table} on #{first_condition}"
 
         @conditions.drop(1).each do |conjunction, condition|
           lines << "#{condition_indent}#{conjunction} #{condition}"
         end
       else
-        lines << "#{continuation_indent}#{@keyword} #{rendered_table}"
+        lines << "#{continuation_indent}#{@keyword} #{lateral_prefix}#{rendered_table}"
       end
 
       lines.join("\n")

data/lib/sql_beautifier/statement_splitter.rb

@@ -2,9 +2,28 @@
 
 module SqlBeautifier
   module StatementSplitter
-    STATEMENT_KEYWORDS = %w[select with create insert update delete].freeze
-    BOUNDARY_KEYWORDS = %w[from where having limit into set values].freeze
-    CONTINUATION_PAIRS = { "insert" => "select" }.freeze
+    STATEMENT_KEYWORDS = %w[
+      select
+      with
+      create
+      insert
+      update
+      delete
+    ].freeze
+
+    BOUNDARY_KEYWORDS = %w[
+      from
+      where
+      having
+      limit
+      into
+      set
+      values
+    ].freeze
+
+    CONTINUATION_PAIRS = {
+      "insert" => "select",
+    }.freeze
 
     module_function
 

data/lib/sql_beautifier/table_reference.rb

@@ -9,7 +9,7 @@ module SqlBeautifier
 
     def self.parse(segment_text)
       table_specification = table_specification_text(segment_text)
-      stripped_specification = table_specification.strip
+      stripped_specification, _lateral = strip_lateral_prefix(table_specification.strip)
 
       return parse_derived_table(stripped_specification) if stripped_specification.start_with?(Constants::OPEN_PARENTHESIS)
 
@@ -52,8 +52,18 @@ module SqlBeautifier
       end
     end
 
+    def self.strip_lateral_prefix(text)
+      stripped = text.strip
+
+      if stripped.match?(Constants::LATERAL_PREFIX_PATTERN)
+        [stripped.sub(Constants::LATERAL_PREFIX_PATTERN, ""), true]
+      else
+        [stripped, false]
+      end
+    end
+
     def self.derived_table_lookup_name_from(text)
-      stripped_text = text.strip
+      stripped_text, _lateral = strip_lateral_prefix(text.strip)
       return unless stripped_text.start_with?(Constants::OPEN_PARENTHESIS)
 
       closing_position = Scanner.new(stripped_text).find_matching_parenthesis(0)

data/lib/sql_beautifier/table_registry.rb

@@ -9,6 +9,7 @@ module SqlBeautifier
       @alias_strategy = SqlBeautifier.config_for(:alias_strategy)
       @references = []
       @references_by_name = {}
+
       build!
     end
 

data/lib/sql_beautifier/tokenizer.rb

@@ -212,6 +212,7 @@ module SqlBeautifier
       scanner = Scanner.new(text)
       conjunction_boundaries = []
       inside_between = false
+      case_depth = 0
 
       until scanner.finished?
         next if scanner.skip_quoted_or_sentinel!
@@ -229,23 +230,37 @@ module SqlBeautifier
           scanner.advance!
         else
           if scanner.parenthesis_depth.zero?
-            inside_between = true if scanner.keyword_at?(Constants::BETWEEN_KEYWORD)
-
-            matched_conjunction = scanner.detect_conjunction_at
-
-            if matched_conjunction
-              if matched_conjunction == "and" && inside_between
-                inside_between = false
-              else
-                conjunction_boundaries << {
-                  conjunction: matched_conjunction,
-                  position: scanner.position,
-                }
-              end
+            if scanner.keyword_at?("case")
+              case_depth += 1
+              scanner.advance!("case".length)
+              next
+            end
 
-              scanner.advance!(matched_conjunction.length)
+            if scanner.keyword_at?("end") && case_depth.positive?
+              case_depth -= 1
+              scanner.advance!("end".length)
               next
             end
+
+            if case_depth.zero?
+              inside_between = true if scanner.keyword_at?(Constants::BETWEEN_KEYWORD)
+
+              matched_conjunction = scanner.detect_conjunction_at
+
+              if matched_conjunction
+                if matched_conjunction == "and" && inside_between
+                  inside_between = false
+                else
+                  conjunction_boundaries << {
+                    conjunction: matched_conjunction,
+                    position: scanner.position,
+                  }
+                end
+
+                scanner.advance!(matched_conjunction.length)
+                next
+              end
+            end
           end
 
           scanner.advance!

data/lib/sql_beautifier/update_query.rb

@@ -92,12 +92,15 @@ module SqlBeautifier
     def render_assignments
       items = Tokenizer.split_by_top_level_commas(@assignments)
       continuation = Util.continuation_padding
+      keyword_width = SqlBeautifier.config_for(:keyword_column_width)
 
       formatted_items = items.map.with_index do |item, index|
+        formatted_item = CaseExpression.format_in_text(item.strip, base_indent: keyword_width)
+
         if index.zero?
-          "\n#{Util.keyword_padding('set')}#{item.strip}"
+          "\n#{Util.keyword_padding('set')}#{formatted_item}"
         else
-          "\n#{continuation}#{item.strip}"
+          "\n#{continuation}#{formatted_item}"
         end
       end
 

data/lib/sql_beautifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SqlBeautifier
-  VERSION = "0.9.2"
+  VERSION = "0.10.0"
 end

data/lib/sql_beautifier.rb

@@ -18,6 +18,7 @@ require_relative "sql_beautifier/statement_splitter"
 require_relative "sql_beautifier/table_reference"
 require_relative "sql_beautifier/table_registry"
 require_relative "sql_beautifier/join"
+require_relative "sql_beautifier/case_expression"
 require_relative "sql_beautifier/expression"
 require_relative "sql_beautifier/sort_expression"
 require_relative "sql_beautifier/condition"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_beautifier
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -66,6 +66,7 @@ files:
 - README.md
 - lib/sql_beautifier.rb
 - lib/sql_beautifier/base.rb
+- lib/sql_beautifier/case_expression.rb
 - lib/sql_beautifier/clauses/base.rb
 - lib/sql_beautifier/clauses/condition_clause.rb
 - lib/sql_beautifier/clauses/from.rb