sql_beautifier 0.1.3 → 0.2.0

data/lib/sql_beautifier/formatter.rb

@@ -20,10 +20,11 @@ module SqlBeautifier
       return "#{@normalized_value}\n" if first_clause_position.nil? || first_clause_position.positive?
 
       @clauses = Tokenizer.split_into_clauses(@normalized_value)
+      @table_registry = TableRegistry.new(@clauses[:from]) if @clauses[:from].present?
       @parts = []
 
       append_clause!(:select, Clauses::Select)
-      append_clause!(:from, Clauses::From)
+      append_from_clause!
       append_clause!(:where, Clauses::Where)
       append_clause!(:group_by, Clauses::GroupBy)
       append_clause!(:having, Clauses::Having)
@@ -33,6 +34,7 @@ module SqlBeautifier
       output = @parts.join("\n\n")
       return "#{@normalized_value}\n" if output.empty?
 
+      output = @table_registry.apply_aliases(output) if @table_registry
       "#{output}\n"
     end
 
@@ -44,5 +46,12 @@ module SqlBeautifier
 
       @parts << formatter_class.call(value)
     end
+
+    def append_from_clause!
+      value = @clauses[:from]
+      return unless value.present?
+
+      @parts << Clauses::From.call(value, table_registry: @table_registry)
+    end
   end
 end

data/lib/sql_beautifier/normalizer.rb

@@ -23,13 +23,13 @@ module SqlBeautifier
 
       while @position < @source.length
         case current_character
-        when "'"
+        when Constants::SINGLE_QUOTE
           consume_string_literal!
 
-        when '"'
+        when Constants::DOUBLE_QUOTE
           consume_quoted_identifier!
 
-        when %r{\s}
+        when Constants::WHITESPACE_CHARACTER_REGEX
           collapse_whitespace!
 
         else
@@ -50,7 +50,7 @@ module SqlBeautifier
     def collapse_whitespace!
       @output << " "
       @position += 1
-      @position += 1 while @position < @source.length && @source[@position] =~ %r{\s}
+      @position += 1 while @position < @source.length && @source[@position] =~ Constants::WHITESPACE_CHARACTER_REGEX
     end
 
     def consume_string_literal!
@@ -61,10 +61,10 @@ module SqlBeautifier
         character = current_character
         @output << character
 
-        if character == "'" && @source[@position + 1] == "'"
+        if character == Constants::SINGLE_QUOTE && @source[@position + 1] == Constants::SINGLE_QUOTE
           @position += 1
           @output << current_character
-        elsif character == "'"
+        elsif character == Constants::SINGLE_QUOTE
           @position += 1
           return
         end
@@ -81,10 +81,10 @@ module SqlBeautifier
       while @position < @source.length
         character = current_character
 
-        if character == '"' && @source[@position + 1] == '"'
-          identifier << '"'
+        if character == Constants::DOUBLE_QUOTE && @source[@position + 1] == Constants::DOUBLE_QUOTE
+          identifier << Constants::DOUBLE_QUOTE
           @position += 2
-        elsif character == '"'
+        elsif character == Constants::DOUBLE_QUOTE
           @position += 1
           @output << format_identifier(identifier)
           return
@@ -100,13 +100,11 @@ module SqlBeautifier
     end
 
     def format_identifier(identifier)
-      lowercased = identifier.downcase
+      downcased_identifier = identifier.downcase
+      return downcased_identifier unless requires_quoting?(downcased_identifier)
 
-      if requires_quoting?(lowercased)
-        "\"#{lowercased.gsub('"', '""')}\""
-      else
-        lowercased
-      end
+      escaped_identifier = Util.escape_double_quote(downcased_identifier)
+      Util.double_quote_string(escaped_identifier)
     end
 
     def requires_quoting?(identifier)

data/lib/sql_beautifier/table_registry.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class TableRegistry
+    attr_reader :table_map
+
+    def initialize(from_content)
+      @from_content = from_content
+      @table_map = {}
+      build!
+    end
+
+    def alias_for(table_name)
+      @table_map[table_name]
+    end
+
+    def apply_aliases(text)
+      output = +""
+      position = 0
+
+      while position < text.length
+        character = text[position]
+
+        case character
+        when Constants::SINGLE_QUOTE
+          position = copy_string_literal!(text, position, output)
+        when Constants::DOUBLE_QUOTE
+          position = copy_quoted_identifier!(text, position, output)
+        else
+          replacement = find_table_replacement_at(text, position)
+
+          if replacement
+            table_name, table_alias = replacement
+
+            output << "#{table_alias}."
+            position += table_name.length + 1
+          else
+            output << character
+            position += 1
+          end
+        end
+      end
+
+      output
+    end
+
+    private
+
+    def build!
+      table_entries = extract_table_entries(@from_content)
+      initials_occurrence_counts = count_initials_occurrences(table_entries)
+      used_aliases = []
+
+      assign_aliases!(table_entries, initials_occurrence_counts, used_aliases)
+      @tables_by_descending_length = @table_map.keys.sort_by { |name| -name.length }.freeze
+    end
+
+    def count_initials_occurrences(table_entries)
+      occurrence_counts = Hash.new(0)
+
+      table_entries.each do |table_entry|
+        next if table_entry[:explicit_alias]
+
+        table_name = table_entry[:table_name]
+        occurrence_counts[table_initials(table_name)] += 1
+      end
+
+      occurrence_counts
+    end
+
+    def assign_aliases!(table_entries, initials_occurrence_counts, used_aliases)
+      duplicate_initials_counts = Hash.new(0)
+      collision_counts = Hash.new(0)
+
+      table_entries.each do |table_entry|
+        table_name = table_entry[:table_name]
+        explicit_alias = table_entry[:explicit_alias]
+
+        if explicit_alias
+          @table_map[table_name] = explicit_alias
+          used_aliases << explicit_alias
+          next
+        end
+
+        initials = table_initials(table_name)
+        duplicate_initials_counts[initials] += 1 if initials_occurrence_counts[initials] > 1
+
+        candidate_alias = begin
+          if initials_occurrence_counts[initials] > 1
+            "#{initials}#{duplicate_initials_counts[initials]}"
+          else
+            initials
+          end
+        end
+
+        if used_aliases.include?(candidate_alias)
+          collision_counts[initials] = [collision_counts[initials], duplicate_initials_counts[initials]].max
+
+          loop do
+            collision_counts[initials] += 1
+            candidate_alias = "#{initials}#{collision_counts[initials]}"
+            break unless used_aliases.include?(candidate_alias)
+          end
+        end
+
+        @table_map[table_name] = candidate_alias
+        used_aliases << candidate_alias
+      end
+    end
+
+    def copy_string_literal!(text, position, output)
+      output << text[position]
+      position += 1
+
+      while position < text.length
+        character = text[position]
+        output << character
+
+        if Tokenizer.escaped_single_quote?(text, position)
+          position += 1
+          output << text[position]
+        elsif character == Constants::SINGLE_QUOTE
+          return position + 1
+        end
+
+        position += 1
+      end
+
+      position
+    end
+
+    def copy_quoted_identifier!(text, position, output)
+      output << text[position]
+      position += 1
+
+      while position < text.length
+        character = text[position]
+        output << character
+
+        if Tokenizer.escaped_double_quote?(text, position)
+          position += 1
+          output << text[position]
+        elsif character == Constants::DOUBLE_QUOTE
+          return position + 1
+        end
+
+        position += 1
+      end
+
+      position
+    end
+
+    def find_table_replacement_at(text, position)
+      return unless Tokenizer.word_boundary?(Tokenizer.character_before(text, position))
+
+      @tables_by_descending_length.each do |table_name|
+        next unless text[position, table_name.length + 1] == "#{table_name}."
+
+        return [table_name, @table_map[table_name]]
+      end
+
+      nil
+    end
+
+    def table_initials(table_name)
+      table_name.split("_").map { |segment| segment[0] }.join
+    end
+
+    def extract_table_entries(from_content)
+      split_segments = from_content.strip.split(Constants::JOIN_KEYWORD_PATTERN)
+
+      table_entries = []
+
+      primary_segment = split_segments.shift.strip
+      table_entries << extract_table_entry(primary_segment)
+
+      split_segments.each_slice(2) do |_join_keyword, join_content|
+        next unless join_content
+
+        table_entries << extract_table_entry(join_content)
+      end
+
+      table_entries.compact
+    end
+
+    def extract_table_entry(segment_text)
+      table_specification = table_specification_text(segment_text)
+      table_name = Util.first_word(table_specification)
+      return unless table_name
+
+      {
+        table_name: table_name,
+        explicit_alias: extract_explicit_alias(table_specification),
+      }
+    end
+
+    def table_specification_text(segment_text)
+      on_keyword_position = Tokenizer.find_top_level_keyword(segment_text, "on")
+      return segment_text.strip unless on_keyword_position
+
+      segment_text[0...on_keyword_position].strip
+    end
+
+    def extract_explicit_alias(table_specification)
+      words = table_specification.strip.split(Constants::WHITESPACE_REGEX)
+      return nil if words.length < 2
+
+      if words[1] == "as"
+        words[2]
+      else
+        words[1]
+      end
+    end
+  end
+end

data/lib/sql_beautifier/tokenizer.rb

@@ -16,8 +16,8 @@ module SqlBeautifier
 
         match_position = match.begin(0)
 
-        previous_character = match_position.zero? ? nil : sql[match_position - 1]
-        next_character = match_position + keyword.length >= sql.length ? nil : sql[match_position + keyword.length]
+        previous_character = character_before(sql, match_position)
+        next_character = character_after(sql, match_position, keyword.length)
 
         return match_position if word_boundary?(previous_character) && word_boundary?(next_character) && top_level?(sql, match_position)
 
@@ -48,7 +48,15 @@ module SqlBeautifier
 
       boundaries.each_with_index do |boundary, boundary_index|
         content_start = boundary[:position] + boundary[:keyword].length
-        content_end = boundary_index + 1 < boundaries.length ? boundaries[boundary_index + 1][:position] : sql.length
+
+        content_end = begin
+          if boundary_index + 1 < boundaries.length
+            boundaries[boundary_index + 1][:position]
+          else
+            sql.length
+          end
+        end
+
         clause_symbol = boundary[:keyword].tr(" ", "_").to_sym
 
         clauses[clause_symbol] = sql[content_start...content_end].strip
@@ -71,10 +79,10 @@ module SqlBeautifier
         if inside_string_literal
           current_segment << character
 
-          if character == "'" && text[position + 1] == "'"
+          if escaped_single_quote?(text, position)
             position += 1
             current_segment << text[position]
-          elsif character == "'"
+          elsif character == Constants::SINGLE_QUOTE
             inside_string_literal = false
           end
 
@@ -85,10 +93,10 @@ module SqlBeautifier
         if inside_quoted_identifier
           current_segment << character
 
-          if character == '"' && text[position + 1] == '"'
+          if escaped_double_quote?(text, position)
             position += 1
             current_segment << text[position]
-          elsif character == '"'
+          elsif character == Constants::DOUBLE_QUOTE
             inside_quoted_identifier = false
           end
 
@@ -97,23 +105,23 @@ module SqlBeautifier
         end
 
         case character
-        when "'"
+        when Constants::SINGLE_QUOTE
           inside_string_literal = true
           current_segment << character
 
-        when '"'
+        when Constants::DOUBLE_QUOTE
           inside_quoted_identifier = true
           current_segment << character
 
-        when "("
+        when Constants::OPEN_PARENTHESIS
           parenthesis_depth += 1
           current_segment << character
 
-        when ")"
+        when Constants::CLOSE_PARENTHESIS
           parenthesis_depth = [parenthesis_depth - 1, 0].max
           current_segment << character
 
-        when ","
+        when Constants::COMMA
           if parenthesis_depth.zero?
             segments << current_segment.strip
             current_segment = +""
@@ -132,10 +140,118 @@ module SqlBeautifier
       segments
     end
 
+    def split_top_level_conditions(text)
+      conjunction_boundaries = scan_top_level_conjunctions(text)
+
+      return [[nil, text.strip]] if conjunction_boundaries.empty?
+
+      condition_pairs = []
+      first_condition_text = text[0...conjunction_boundaries.first[:position]].strip
+      condition_pairs << [nil, first_condition_text]
+
+      conjunction_boundaries.each_with_index do |boundary, boundary_index|
+        content_start = boundary[:position] + boundary[:conjunction].length
+
+        content_end = begin
+          if boundary_index + 1 < conjunction_boundaries.length
+            conjunction_boundaries[boundary_index + 1][:position]
+          else
+            text.length
+          end
+        end
+
+        condition_text = text[content_start...content_end].strip
+
+        condition_pairs << [boundary[:conjunction], condition_text]
+      end
+
+      condition_pairs
+    end
+
+    def find_matching_parenthesis(text, opening_position)
+      parenthesis_depth = 0
+      inside_string_literal = false
+      inside_quoted_identifier = false
+      position = opening_position
+
+      while position < text.length
+        character = text[position]
+
+        if inside_string_literal
+          if escaped_single_quote?(text, position)
+            position += 2
+            next
+          elsif character == Constants::SINGLE_QUOTE
+            inside_string_literal = false
+          end
+
+          position += 1
+          next
+        end
+
+        if inside_quoted_identifier
+          if escaped_double_quote?(text, position)
+            position += 2
+            next
+          elsif character == Constants::DOUBLE_QUOTE
+            inside_quoted_identifier = false
+          end
+
+          position += 1
+          next
+        end
+
+        case character
+        when Constants::SINGLE_QUOTE
+          inside_string_literal = true
+        when Constants::DOUBLE_QUOTE
+          inside_quoted_identifier = true
+        when Constants::OPEN_PARENTHESIS
+          parenthesis_depth += 1
+        when Constants::CLOSE_PARENTHESIS
+          parenthesis_depth -= 1
+          return position if parenthesis_depth.zero?
+        end
+
+        position += 1
+      end
+
+      nil
+    end
+
+    def outer_parentheses_wrap_all?(text)
+      trimmed_text = text.strip
+      return false unless trimmed_text.start_with?(Constants::OPEN_PARENTHESIS)
+
+      closing_parenthesis_position = find_matching_parenthesis(trimmed_text, 0)
+
+      closing_parenthesis_position == trimmed_text.length - 1
+    end
+
     def word_boundary?(character)
       character.nil? || character !~ IDENTIFIER_CHARACTER
     end
 
+    def character_before(text, position)
+      return nil if position.zero?
+
+      text[position - 1]
+    end
+
+    def character_after(text, position, offset)
+      return nil if position + offset >= text.length
+
+      text[position + offset]
+    end
+
+    def escaped_single_quote?(text, position)
+      text[position] == Constants::SINGLE_QUOTE && text[position + 1] == Constants::SINGLE_QUOTE
+    end
+
+    def escaped_double_quote?(text, position)
+      text[position] == Constants::DOUBLE_QUOTE && text[position + 1] == Constants::DOUBLE_QUOTE
+    end
+
     def top_level?(sql, target_position)
       parenthesis_depth = 0
       inside_string_literal = false
@@ -146,10 +262,10 @@ module SqlBeautifier
         character = sql[position]
 
         if inside_string_literal
-          if character == "'" && sql[position + 1] == "'"
+          if escaped_single_quote?(sql, position)
             position += 2
             next
-          elsif character == "'"
+          elsif character == Constants::SINGLE_QUOTE
             inside_string_literal = false
           end
 
@@ -158,10 +274,10 @@ module SqlBeautifier
         end
 
         if inside_quoted_identifier
-          if character == '"' && sql[position + 1] == '"'
+          if escaped_double_quote?(sql, position)
             position += 2
             next
-          elsif character == '"'
+          elsif character == Constants::DOUBLE_QUOTE
             inside_quoted_identifier = false
           end
 
@@ -170,13 +286,13 @@ module SqlBeautifier
         end
 
         case character
-        when "'"
+        when Constants::SINGLE_QUOTE
           inside_string_literal = true
-        when '"'
+        when Constants::DOUBLE_QUOTE
           inside_quoted_identifier = true
-        when "("
+        when Constants::OPEN_PARENTHESIS
           parenthesis_depth += 1
-        when ")"
+        when Constants::CLOSE_PARENTHESIS
           parenthesis_depth = [parenthesis_depth - 1, 0].max
         end
 
@@ -185,5 +301,92 @@ module SqlBeautifier
 
       parenthesis_depth.zero? && !inside_string_literal && !inside_quoted_identifier
     end
+
+    def scan_top_level_conjunctions(text)
+      conjunction_boundaries = []
+      parenthesis_depth = 0
+      inside_string_literal = false
+      inside_quoted_identifier = false
+      inside_between = false
+      position = 0
+
+      while position < text.length
+        character = text[position]
+
+        if inside_string_literal
+          if escaped_single_quote?(text, position)
+            position += 2
+          elsif character == Constants::SINGLE_QUOTE
+            inside_string_literal = false
+            position += 1
+          else
+            position += 1
+          end
+          next
+        end
+
+        if inside_quoted_identifier
+          if escaped_double_quote?(text, position)
+            position += 2
+          elsif character == Constants::DOUBLE_QUOTE
+            inside_quoted_identifier = false
+            position += 1
+          else
+            position += 1
+          end
+          next
+        end
+
+        case character
+        when Constants::SINGLE_QUOTE
+          inside_string_literal = true
+        when Constants::DOUBLE_QUOTE
+          inside_quoted_identifier = true
+        when Constants::OPEN_PARENTHESIS
+          parenthesis_depth += 1
+        when Constants::CLOSE_PARENTHESIS
+          parenthesis_depth = [parenthesis_depth - 1, 0].max
+        else
+          if parenthesis_depth.zero?
+            inside_between = true if keyword_at?(text, position, Constants::BETWEEN_KEYWORD)
+
+            matched_conjunction = detect_conjunction_at(text, position)
+
+            if matched_conjunction
+              if matched_conjunction == "and" && inside_between
+                inside_between = false
+              else
+                conjunction_boundaries << {
+                  conjunction: matched_conjunction,
+                  position: position,
+                }
+              end
+
+              position += matched_conjunction.length
+              next
+            end
+          end
+        end
+
+        position += 1
+      end
+
+      conjunction_boundaries
+    end
+
+    def keyword_at?(text, position, keyword)
+      return false unless text[position, keyword.length]&.downcase == keyword
+
+      previous_character = character_before(text, position)
+      next_character = character_after(text, position, keyword.length)
+
+      word_boundary?(previous_character) && word_boundary?(next_character)
+    end
+
+    def detect_conjunction_at(text, position)
+      Constants::CONJUNCTIONS.detect do |conjunction|
+        keyword_at?(text, position, conjunction)
+      end
+    end
   end
 end

data/lib/sql_beautifier/util.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module Util
+    module_function
+
+    def upper_pascal_case(name)
+      name.split("_").map(&:capitalize).join("_")
+    end
+
+    def first_word(text)
+      text.strip.split(Constants::WHITESPACE_REGEX).first
+    end
+
+    def strip_outer_parentheses(text)
+      stripped_text = text.strip
+      return stripped_text unless stripped_text.start_with?(Constants::OPEN_PARENTHESIS) && stripped_text.end_with?(Constants::CLOSE_PARENTHESIS)
+
+      stripped_text[1...-1].strip
+    end
+
+    def double_quote_string(value)
+      return if value.nil?
+
+      "#{Constants::DOUBLE_QUOTE}#{value}#{Constants::DOUBLE_QUOTE}"
+    end
+
+    def escape_double_quote(value)
+      return if value.nil?
+
+      value.gsub(Constants::DOUBLE_QUOTE, Constants::ESCAPED_DOUBLE_QUOTE)
+    end
+  end
+end

data/lib/sql_beautifier/version.rb

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