sql_beautifier 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 189e4fb1ebb3e61fa40afa896d3ac83897714fb3236f3ef27a1a97da03c82fea
-  data.tar.gz: 9143a35ed8be4d33372d1d82bb05ec52d8acf3eb2ce34ea5880e0b7e5e53b2f9
+  metadata.gz: 4a22a4c99d49622a7631196a0622d66ebcfb81144bbd85238e854cf5fb7ad6d3
+  data.tar.gz: 685310c29776884c4164feeb272d6fdac9fb4e640df7272170ba6b0530ef10b4
 SHA512:
-  metadata.gz: 991c1470b7beb1db6c405b709d5ee96f9d7562c27882e5a4f8269a2f3680d50a3787c326df87bd04c7331cab0b87f7c5b87867f03a094f5628f39cfaf0376bd9
-  data.tar.gz: a8cc4f9eed82b92905be0961adea425731ad5741e941b5eb6aa669341dbc1bb97ba6540721f9734497009823075769257fccae7ae4416b84ba76fa172b5d6694
+  metadata.gz: a4df9d20c0c4c92c6fe59ffbaa270ab82ed7356ffdb545d2055cae874d35c1f64347dd67971ac1260bfced3bf41cfd9dbf83bc77472ed5c1664b18772e4210c4
+  data.tar.gz: 26aebcef3cd11bc88dd898faee9d693bc72458e130ec814370c6163a903bbabb33c9cedd10cb40aadd5b7ea2f6ebc1edb42c0e8a21dc5471ca2a5c7ec0412c37

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.8.0] - 2026-03-29
+
+- Add compound query support for set operators (`UNION`, `UNION ALL`, `INTERSECT`, `INTERSECT ALL`, `EXCEPT`, `EXCEPT ALL`) — top-level set operator boundaries are detected via `Scanner`, each segment is independently formatted through the `Formatter` pipeline, and operators appear on their own line with blank-line separation
+- Introduce `CompoundQuery` entity class with `parse`/`render` following the `Base` + `dry-initializer` pattern established by `CteQuery` and `CreateTableAs`
+- Add trailing clause handling for compound queries — `ORDER BY` and `LIMIT` after the final segment are extracted and rendered separately below the last formatted segment
+- Fix `StatementSplitter` incorrectly splitting compound queries at the second `SELECT` — set operator keywords at depth 0 now suppress statement boundary detection for the following `SELECT`
+- Add `SET_OPERATORS` constant to `Constants` (longest-first order for greedy matching)
+
 ## [0.7.0] - 2026-03-29
 
 - Introduce `Query` entity encapsulating parsed clauses, depth, table registry, compact detection, and subquery formatting — `Formatter` delegates clause assembly and rendering to `Query`, and `SubqueryFormatter` is eliminated

data/README.md

@@ -227,6 +227,61 @@ order by created_at desc
 limit 25;
 ```
 
+### Set Operators (UNION, INTERSECT, EXCEPT)
+
+Compound queries joined by set operators are detected and each segment is formatted independently. The operator keyword appears on its own line with blank-line separation:
+
+```ruby
+SqlBeautifier.call(<<~SQL)
+  SELECT id, name FROM users WHERE active = true
+  UNION ALL
+  SELECT id, name FROM admins WHERE role = 'super'
+SQL
+```
+
+Produces:
+
+```sql
+select  id,
+        name
+
+from    Users u
+
+where   active = true
+
+union all
+
+select  id,
+        name
+
+from    Admins a
+
+where   role = 'super';
+```
+
+Supported operators: `UNION`, `UNION ALL`, `INTERSECT`, `INTERSECT ALL`, `EXCEPT`, `EXCEPT ALL`. Multiple operators can be mixed in a single query. Trailing `ORDER BY` and `LIMIT` that apply to the compound result are rendered after the last segment:
+
+```ruby
+SqlBeautifier.call("SELECT id FROM users UNION ALL SELECT id FROM admins ORDER BY id LIMIT 10")
+```
+
+Produces:
+
+```sql
+select  id
+from    Users u
+
+union all
+
+select  id
+from    Admins a
+
+order by id
+limit 10;
+```
+
+Set operators inside parenthesized subqueries are handled correctly and do not split the outer query. Each segment is formatted with its own independent table registry, so alias collisions between segments are not a concern.
+
 ### String Literals
 
 Case is preserved inside single-quoted string literals, and escaped quotes (`''`) are handled correctly:

data/lib/sql_beautifier/compound_query.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class CompoundQuery < Base
+    TRAILING_CLAUSE_KEYWORDS = ["order by", "limit"].freeze
+
+    option :segments
+    option :trailing_clauses, default: -> {}
+    option :depth, default: -> { 0 }
+
+    def self.parse(normalized_sql, depth: 0)
+      boundaries = scan_set_operator_boundaries(normalized_sql)
+      return nil if boundaries.empty?
+
+      segments = build_segments(normalized_sql, boundaries)
+      trailing_clauses = extract_trailing_clauses!(segments)
+
+      new(segments: segments, trailing_clauses: trailing_clauses, depth: depth)
+    end
+
+    def render
+      formatted_segments = []
+
+      @segments.each_with_index do |segment, index|
+        formatted_sql = Formatter.new(segment[:sql], depth: @depth).call
+        return nil unless formatted_sql
+
+        output = +""
+        output << "\n#{Util.format_keyword(segment[:operator])}\n\n" if index.positive? && segment[:operator]
+        output << formatted_sql.chomp
+        formatted_segments << output
+      end
+
+      return nil if formatted_segments.empty?
+
+      result = formatted_segments.join("\n")
+      result << render_trailing_clauses if @trailing_clauses.present?
+
+      "#{result}\n"
+    end
+
+    def self.scan_set_operator_boundaries(normalized_sql)
+      scanner = Scanner.new(normalized_sql)
+      boundaries = []
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        case scanner.current_char
+        when Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+        when Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+        else
+          if scanner.parenthesis_depth.zero?
+            matched_operator = detect_set_operator(scanner)
+
+            if matched_operator
+              boundaries << { operator: matched_operator, position: scanner.position }
+              scanner.advance!(matched_operator.length)
+              next
+            end
+          end
+        end
+
+        scanner.advance!
+      end
+
+      boundaries
+    end
+
+    def self.detect_set_operator(scanner)
+      Constants::SET_OPERATORS.detect { |operator| scanner.keyword_at?(operator) }
+    end
+
+    def self.build_segments(normalized_sql, boundaries)
+      segments = []
+
+      boundaries.each_with_index do |boundary, index|
+        previous_boundary = boundaries[index - 1] unless index.zero?
+        segment_start = previous_boundary ? previous_boundary[:position] + previous_boundary[:operator].length : 0
+        segment_sql = normalized_sql[segment_start...boundary[:position]].strip
+
+        segments << { operator: previous_boundary&.fetch(:operator), sql: segment_sql }
+      end
+
+      last_boundary = boundaries.last
+      final_segment_start = last_boundary[:position] + last_boundary[:operator].length
+      final_segment_sql = normalized_sql[final_segment_start..].strip
+
+      segments << { operator: last_boundary[:operator], sql: final_segment_sql }
+
+      segments
+    end
+
+    def self.extract_trailing_clauses!(segments)
+      final_segment = segments.last
+      return nil unless final_segment
+
+      sql = final_segment[:sql]
+      trailing_start = find_trailing_clause_start(sql)
+      return nil unless trailing_start
+
+      trailing_sql = sql[trailing_start..].strip
+      final_segment[:sql] = sql[0...trailing_start].strip
+
+      trailing_sql
+    end
+
+    def self.find_trailing_clause_start(sql)
+      scanner = Scanner.new(sql)
+      trailing_position = nil
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        case scanner.current_char
+        when Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+        when Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+        else
+          if scanner.parenthesis_depth.zero?
+            matched_trailing_keyword = TRAILING_CLAUSE_KEYWORDS.detect { |keyword| scanner.keyword_at?(keyword) }
+            trailing_position ||= scanner.position if matched_trailing_keyword
+          end
+        end
+
+        scanner.advance!
+      end
+
+      trailing_position
+    end
+
+    private_class_method :scan_set_operator_boundaries, :detect_set_operator, :build_segments, :extract_trailing_clauses!, :find_trailing_clause_start
+
+    private
+
+    def render_trailing_clauses
+      clauses = Tokenizer.split_into_clauses(@trailing_clauses)
+      return "" if clauses.empty?
+
+      clause_renderers = {
+        order_by: Clauses::OrderBy,
+        limit: Clauses::Limit,
+      }
+
+      rendered_clauses = clauses.filter_map do |clause_key, clause_value|
+        renderer = clause_renderers[clause_key]
+        next unless renderer
+
+        renderer.call(clause_value)
+      end
+
+      return "" if rendered_clauses.empty?
+
+      "\n\n#{rendered_clauses.join("\n")}"
+    end
+  end
+end

data/lib/sql_beautifier/constants.rb

@@ -26,6 +26,15 @@ module SqlBeautifier
     JOIN_KEYWORDS_BY_LENGTH = JOIN_KEYWORDS.sort_by { |keyword| -keyword.length }.freeze
     JOIN_KEYWORD_PATTERN = %r{\b(#{JOIN_KEYWORDS.map { |keyword| Regexp.escape(keyword) }.join('|')})\b}i
 
+    SET_OPERATORS = [
+      "intersect all",
+      "except all",
+      "union all",
+      "intersect",
+      "except",
+      "union",
+    ].freeze
+
     CONJUNCTIONS = %w[and or].freeze
     BETWEEN_KEYWORD = "between"
 

data/lib/sql_beautifier/formatter.rb

@@ -29,6 +29,9 @@ module SqlBeautifier
       create_table_as_result = CreateTableAs.parse(@normalized_value, depth: @depth)&.render
       return prepend_sentinels(create_table_as_result) if create_table_as_result
 
+      compound_result = CompoundQuery.parse(@normalized_value, depth: @depth)&.render
+      return prepend_sentinels(compound_result) if compound_result
+
       first_clause_position = Tokenizer.first_clause_position(@normalized_value)
       return prepend_sentinels("#{@normalized_value}\n") if first_clause_position.nil? || first_clause_position.positive?
 

data/lib/sql_beautifier/statement_splitter.rb

@@ -85,6 +85,7 @@ module SqlBeautifier
       boundaries = []
       clause_seen = false
       current_statement_keyword = nil
+      after_set_operator = false
 
       until scanner.finished?
         next if scanner.skip_quoted_or_sentinel!
@@ -102,10 +103,20 @@ module SqlBeautifier
           scanner.advance!
         else
           if scanner.parenthesis_depth.zero?
+            matched_set_operator = keyword_match_at(scanner, Constants::SET_OPERATORS)
+
+            if matched_set_operator
+              after_set_operator = true
+              scanner.advance!(matched_set_operator.length)
+              next
+            end
+
             matched_statement_keyword = keyword_match_at(scanner, STATEMENT_KEYWORDS)
 
             if matched_statement_keyword
-              if clause_seen && !continuation_keyword?(current_statement_keyword, matched_statement_keyword)
+              if after_set_operator
+                after_set_operator = false
+              elsif clause_seen && !continuation_keyword?(current_statement_keyword, matched_statement_keyword)
                 boundaries << scanner.position
                 clause_seen = false
                 current_statement_keyword = matched_statement_keyword

data/lib/sql_beautifier/version.rb

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

data/lib/sql_beautifier.rb

@@ -24,6 +24,7 @@ require_relative "sql_beautifier/condition"
 require_relative "sql_beautifier/cte_definition"
 require_relative "sql_beautifier/cte_query"
 require_relative "sql_beautifier/create_table_as"
+require_relative "sql_beautifier/compound_query"
 require_relative "sql_beautifier/clauses/base"
 require_relative "sql_beautifier/clauses/condition_clause"
 require_relative "sql_beautifier/clauses/select"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_beautifier
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -77,6 +77,7 @@ files:
 - lib/sql_beautifier/clauses/where.rb
 - lib/sql_beautifier/comment.rb
 - lib/sql_beautifier/comment_parser.rb
+- lib/sql_beautifier/compound_query.rb
 - lib/sql_beautifier/condition.rb
 - lib/sql_beautifier/configuration.rb
 - lib/sql_beautifier/constants.rb