sql_beautifier 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6df1f55c9242793101e9f562329763541d56aa4f17f7e3d81a12038ab5b53cca
-  data.tar.gz: 43fea825ac0c4bded07098814a2ed67e5503e1829f3d47cc99a7c989ec0e69d1
+  metadata.gz: 74ce2777ba2e1a7635aa92623cbb6e252bef41abafa62fff7b3f9f651aad05af
+  data.tar.gz: 83f543391d4e60f2ab928eb44c6975d4f935b84c7e63bcbb05685331bcdf59a2
 SHA512:
-  metadata.gz: d56c72c27d4b71781be0ee83ba44fb3a4e466567c5edbde267c2cfbeb245c81e78bc52a309d27e7dae69a2a7e3cbf1bb3ce55926a266a6c914e822140b6650b7
-  data.tar.gz: 9e2e5118b5b12e52551300e2c0219c6cc42907fdb87fd56a8e6e80e193b212ae36ff87ee48d2a0135dc0140121d145c3f104622a0efbd0a3bbeffe10af378cea
+  metadata.gz: 3bbfe00044b32a468fb019a9d32010ce355803000d627d6b16146398b54515531d0a6b76a84022facaec39b1afb849307b08ee96b8859b00ad99f7f2895b2668
+  data.tar.gz: 2252b3c944667589b17c0bde79e2eca176ced558c6bf8d19795607490788dc468200a00a2dedbce667adee966956389b3957f70cc39fa317d865435ceee22007

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.5.0] - 2026-03-28
+
+- Add support for Create Table As (CTA) formatting
+
+## [0.4.0] - 2026-03-27
+
+- Add CTE (Common Table Expression) formatting with recursive indentation
+
 ## [0.3.0] - 2026-03-27
 
 - Add configuration system with `SqlBeautifier.configure` block and `SqlBeautifier.reset_configuration!`

data/lib/sql_beautifier/condition_formatter.rb

@@ -4,7 +4,8 @@ module SqlBeautifier
   module ConditionFormatter
     module_function
 
-    def format(text, indent_width:)
+    def format(text, args = {})
+      indent_width = args.fetch(:indent_width, 0)
       conditions = Tokenizer.split_top_level_conditions(text)
       return text.strip if conditions.length <= 1 && !parse_condition_group(conditions.dig(0, 1))
 

data/lib/sql_beautifier/create_table_as_formatter.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module CreateTableAsFormatter
+    MODIFIERS = %w[
+      temp
+      temporary
+      unlogged
+      local
+    ].freeze
+
+    WITH_DATA_SUFFIX_REGEX = %r{\s+(with\s+(?:no\s+)?data)\s*\z}i
+
+    module_function
+
+    def format(normalized_sql, _args = {})
+      return nil unless create_table_as_query?(normalized_sql)
+
+      parsed = parse(normalized_sql)
+      return nil unless parsed
+
+      format_statement(parsed[:preamble], parsed[:body], parsed[:suffix])
+    end
+
+    def create_table_as_query?(sql)
+      Tokenizer.keyword_at?(sql, 0, "create")
+    end
+
+    def parse(sql)
+      position = 0
+      return nil unless Tokenizer.keyword_at?(sql, position, "create")
+
+      position = skip_past_keyword(sql, position, "create")
+
+      modifier = detect_modifier(sql, position)
+      position = skip_past_keyword(sql, position, modifier) if modifier
+
+      return nil unless Tokenizer.keyword_at?(sql, position, "table")
+
+      position = skip_past_keyword(sql, position, "table")
+
+      if_not_exists = detect_if_not_exists?(sql, position)
+      position = skip_past_if_not_exists(sql, position) if if_not_exists
+
+      table_name, position = read_identifier(sql, position)
+      return nil unless table_name
+
+      position = skip_whitespace(sql, position)
+      return nil unless Tokenizer.keyword_at?(sql, position, "as")
+
+      position = skip_past_keyword(sql, position, "as")
+
+      result = extract_body(sql, position)
+      return nil unless result
+
+      body_sql, suffix = result
+      return nil unless body_sql
+
+      preamble = build_preamble(modifier, if_not_exists, table_name)
+      { preamble: preamble, body: body_sql, suffix: suffix }
+    end
+
+    def detect_modifier(sql, position)
+      MODIFIERS.detect { |modifier| Tokenizer.keyword_at?(sql, position, modifier) }
+    end
+
+    def detect_if_not_exists?(sql, position)
+      Tokenizer.keyword_at?(sql, position, "if") && Tokenizer.keyword_at?(sql, skip_past_keyword(sql, position, "if"), "not") && Tokenizer.keyword_at?(sql, skip_past_keyword(sql, skip_past_keyword(sql, position, "if"), "not"), "exists")
+    end
+
+    def skip_past_if_not_exists(sql, position)
+      position = skip_past_keyword(sql, position, "if")
+      position = skip_past_keyword(sql, position, "not")
+      skip_past_keyword(sql, position, "exists")
+    end
+
+    def extract_body(sql, position)
+      position = skip_whitespace(sql, position)
+      return nil if position >= sql.length
+
+      if sql[position] == Constants::OPEN_PARENTHESIS
+        closing = Tokenizer.find_matching_parenthesis(sql, position)
+        return nil unless closing
+
+        body = sql[(position + 1)...closing].strip
+        suffix = sql[(closing + 1)..].strip.presence
+        [body, suffix]
+      else
+        extract_unparenthesized_body(sql[position..].strip)
+      end
+    end
+
+    def extract_unparenthesized_body(raw_body)
+      return nil unless raw_body.present?
+
+      match = raw_body.match(WITH_DATA_SUFFIX_REGEX)
+
+      if match
+        body = raw_body[0...match.begin(0)].strip
+        return nil unless body.present?
+
+        [body, match[1]]
+      else
+        [raw_body, nil]
+      end
+    end
+
+    def build_preamble(modifier, if_not_exists, table_name)
+      parts = [Util.format_keyword("create")]
+      parts << Util.format_keyword(modifier) if modifier
+      parts << Util.format_keyword("table")
+      parts << "#{Util.format_keyword('if')} #{Util.format_keyword('not')} #{Util.format_keyword('exists')}" if if_not_exists
+      parts << Util.format_table_name(table_name)
+      parts << Util.format_keyword("as")
+      parts.join(" ")
+    end
+
+    def format_statement(preamble, body_sql, suffix)
+      indent_spaces = SqlBeautifier.config_for(:indent_spaces) || 4
+      formatted = Formatter.new(body_sql, depth: 0).call
+      return "#{preamble}\n" unless formatted
+
+      indentation = Util.whitespace(indent_spaces)
+      indented_lines = formatted.chomp.lines.map { |line| line.strip.empty? ? "\n" : "#{indentation}#{line}" }.join
+
+      formatted_suffix = suffix ? " #{format_suffix(suffix)}" : ""
+      "#{preamble} (\n#{indented_lines}\n)#{formatted_suffix}\n"
+    end
+
+    def format_suffix(suffix)
+      suffix.strip.split(%r{\s+}).map { |word| Util.format_keyword(word) }.join(" ")
+    end
+
+    def read_identifier(sql, position)
+      position = skip_whitespace(sql, position)
+      return nil if position >= sql.length
+
+      if sql[position] == Constants::DOUBLE_QUOTE
+        start = position
+        position += 1
+
+        while position < sql.length
+          if sql[position] == Constants::DOUBLE_QUOTE
+            if position + 1 < sql.length && sql[position + 1] == Constants::DOUBLE_QUOTE
+              position += 2
+              next
+            end
+
+            position += 1
+            break
+          end
+
+          position += 1
+        end
+
+        return nil unless position <= sql.length && sql[position - 1] == Constants::DOUBLE_QUOTE
+
+        return [sql[start...position], position]
+      end
+
+      start = position
+      position += 1 while position < sql.length && sql[position] =~ Tokenizer::IDENTIFIER_CHARACTER
+      return nil if position == start
+
+      [sql[start...position], position]
+    end
+
+    def skip_whitespace(sql, position)
+      position += 1 while position < sql.length && sql[position] =~ Constants::WHITESPACE_CHARACTER_REGEX
+      position
+    end
+
+    def skip_past_keyword(sql, position, keyword)
+      skip_whitespace(sql, position + keyword.length)
+    end
+  end
+end

data/lib/sql_beautifier/cte_formatter.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module CteFormatter
+    module_function
+
+    def format(normalized_sql, args = {})
+      depth = args.fetch(:depth, 0)
+      return nil unless cte_query?(normalized_sql)
+
+      recursive, definitions, main_query_sql = parse(normalized_sql)
+      return nil unless definitions.any? && main_query_sql.present?
+
+      format_cte_statement(recursive, definitions, main_query_sql, depth)
+    end
+
+    def cte_query?(sql)
+      Tokenizer.keyword_at?(sql, 0, "with")
+    end
+
+    def parse(sql)
+      position = skip_past_keyword(sql, 0, "with")
+
+      recursive = Tokenizer.keyword_at?(sql, position, "recursive")
+      position = skip_past_keyword(sql, position, "recursive") if recursive
+
+      definitions = []
+
+      loop do
+        definition, new_position = parse_definition(sql, position)
+        break unless definition
+
+        definitions << definition
+        position = skip_whitespace(sql, new_position)
+
+        break unless position < sql.length && sql[position] == Constants::COMMA
+
+        position = skip_whitespace(sql, position + 1)
+      end
+
+      main_query_sql = sql[position..].strip
+
+      [recursive, definitions, main_query_sql]
+    end
+
+    def parse_definition(sql, position)
+      name, position = read_identifier(sql, position)
+      return nil unless name
+
+      position = skip_whitespace(sql, position)
+
+      column_list = parse_column_list(sql, position)
+      position = column_list[:next_position] if column_list
+
+      return nil unless Tokenizer.keyword_at?(sql, position, "as")
+
+      position = skip_past_keyword(sql, position, "as")
+      materialization, position = parse_materialization(sql, position)
+
+      return nil unless position < sql.length && sql[position] == Constants::OPEN_PARENTHESIS
+
+      closing = Tokenizer.find_matching_parenthesis(sql, position)
+      return nil unless closing
+
+      body_sql = sql[(position + 1)...closing].strip
+      definition = { name: name, body: body_sql }
+      definition[:column_list] = column_list[:text] if column_list
+      definition[:materialization] = materialization if materialization
+
+      [definition, closing + 1]
+    end
+
+    def parse_column_list(sql, position)
+      return nil unless position < sql.length && sql[position] == Constants::OPEN_PARENTHESIS
+
+      closing = Tokenizer.find_matching_parenthesis(sql, position)
+      return nil unless closing
+
+      after_paren = skip_whitespace(sql, closing + 1)
+      return nil unless Tokenizer.keyword_at?(sql, after_paren, "as")
+
+      { text: sql[(position + 1)...closing].strip, next_position: after_paren }
+    end
+
+    def format_cte_statement(recursive, definitions, main_query_sql, depth)
+      keyword_width = SqlBeautifier.config_for(:keyword_column_width)
+      cte_name_column = keyword_width
+      continuation_indent = Util.continuation_padding
+
+      output = +""
+
+      definitions.each_with_index do |definition, index|
+        if index.zero?
+          output << Util.keyword_padding("with")
+          output << "#{Util.format_keyword('recursive')} " if recursive
+        else
+          output << continuation_indent
+        end
+
+        output << definition_header(definition)
+        output << format_body(definition[:body], cte_name_column)
+        output << (index < definitions.length - 1 ? ",\n" : "\n\n")
+      end
+
+      formatted_main = Formatter.new(main_query_sql, depth: depth).call
+      output << formatted_main if formatted_main
+
+      output
+    end
+
+    def definition_header(definition)
+      header = +definition[:name].to_s
+      header << " (#{definition[:column_list]})" if definition[:column_list]
+      header << " #{Util.format_keyword('as')}"
+      header << " #{format_materialization(definition[:materialization])}" if definition[:materialization]
+      header << " "
+      header
+    end
+
+    def parse_materialization(sql, position)
+      position = skip_whitespace(sql, position)
+      return ["materialized", skip_past_keyword(sql, position, "materialized")] if Tokenizer.keyword_at?(sql, position, "materialized")
+      return [nil, position] unless Tokenizer.keyword_at?(sql, position, "not")
+
+      materialized_position = skip_past_keyword(sql, position, "not")
+      return [nil, position] unless Tokenizer.keyword_at?(sql, materialized_position, "materialized")
+
+      ["not materialized", skip_past_keyword(sql, materialized_position, "materialized")]
+    end
+
+    def format_materialization(materialization)
+      return Util.format_keyword("materialized") if materialization == "materialized"
+
+      [Util.format_keyword("not"), Util.format_keyword("materialized")].join(" ")
+    end
+
+    def format_body(body_sql, base_indent)
+      indent_spaces = SqlBeautifier.config_for(:indent_spaces) || 4
+      body_indent = base_indent + indent_spaces
+      formatted = Formatter.new(body_sql, depth: 0).call
+      return "(#{body_sql})" unless formatted
+
+      indentation = Util.whitespace(body_indent)
+      indented_lines = formatted.chomp.lines.map { |line| line.strip.empty? ? "\n" : "#{indentation}#{line}" }.join
+
+      "(\n#{indented_lines}\n#{Util.whitespace(base_indent)})"
+    end
+
+    def read_identifier(sql, position)
+      position = skip_whitespace(sql, position)
+      return nil if position >= sql.length
+
+      if sql[position] == Constants::DOUBLE_QUOTE
+        start = position
+        position += 1
+
+        while position < sql.length
+          if sql[position] == Constants::DOUBLE_QUOTE
+            if position + 1 < sql.length && sql[position + 1] == Constants::DOUBLE_QUOTE
+              position += 2
+              next
+            end
+
+            position += 1
+            break
+          end
+
+          position += 1
+        end
+
+        return nil unless position <= sql.length && sql[position - 1] == Constants::DOUBLE_QUOTE
+
+        return [sql[start...position], position]
+      end
+
+      start = position
+      position += 1 while position < sql.length && sql[position] =~ Tokenizer::IDENTIFIER_CHARACTER
+      return nil if position == start
+
+      [sql[start...position], position]
+    end
+
+    def skip_whitespace(sql, position)
+      position += 1 while position < sql.length && sql[position] =~ Constants::WHITESPACE_CHARACTER_REGEX
+      position
+    end
+
+    def skip_past_keyword(sql, position, keyword)
+      skip_whitespace(sql, position + keyword.length)
+    end
+  end
+end

data/lib/sql_beautifier/formatter.rb

@@ -17,6 +17,12 @@ module SqlBeautifier
       @normalized_value = Normalizer.call(@value)
       return unless @normalized_value.present?
 
+      cte_result = CteFormatter.format(@normalized_value, depth: @depth)
+      return cte_result if cte_result
+
+      create_table_as_result = CreateTableAsFormatter.format(@normalized_value, depth: @depth)
+      return create_table_as_result if create_table_as_result
+
       first_clause_position = Tokenizer.first_clause_position(@normalized_value)
       return "#{@normalized_value}\n" if first_clause_position.nil? || first_clause_position.positive?
 

data/lib/sql_beautifier/version.rb

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

data/lib/sql_beautifier.rb

@@ -12,6 +12,8 @@ require_relative "sql_beautifier/tokenizer"
 require_relative "sql_beautifier/table_registry"
 require_relative "sql_beautifier/condition_formatter"
 require_relative "sql_beautifier/subquery_formatter"
+require_relative "sql_beautifier/cte_formatter"
+require_relative "sql_beautifier/create_table_as_formatter"
 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.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -49,6 +49,8 @@ files:
 - lib/sql_beautifier/condition_formatter.rb
 - lib/sql_beautifier/configuration.rb
 - lib/sql_beautifier/constants.rb
+- lib/sql_beautifier/create_table_as_formatter.rb
+- lib/sql_beautifier/cte_formatter.rb
 - lib/sql_beautifier/formatter.rb
 - lib/sql_beautifier/normalizer.rb
 - lib/sql_beautifier/subquery_formatter.rb