sql_beautifier 0.6.0 → 0.7.0

data/lib/sql_beautifier/statement_splitter.rb

@@ -15,102 +15,42 @@ module SqlBeautifier
     end
 
     def split_on_semicolons(sql)
+      scanner = Scanner.new(sql)
       segments = []
       current_segment = +""
-      inside_string_literal = false
-      inside_quoted_identifier = false
-      inside_dollar_quoted_string = false
-      dollar_quote_delimiter = nil
-      parenthesis_depth = 0
-      position = 0
 
-      while position < sql.length
-        character = sql[position]
-
-        if inside_string_literal
-          current_segment << character
-
-          if character == Constants::SINGLE_QUOTE && sql[position + 1] == Constants::SINGLE_QUOTE
-            position += 1
-            current_segment << sql[position]
-          elsif character == Constants::SINGLE_QUOTE
-            inside_string_literal = false
-          end
-
-          position += 1
-          next
-        end
-
-        if inside_dollar_quoted_string
-          if sql[position, dollar_quote_delimiter.length] == dollar_quote_delimiter
-            current_segment << dollar_quote_delimiter
-            position += dollar_quote_delimiter.length
-            inside_dollar_quoted_string = false
-            dollar_quote_delimiter = nil
-          else
-            current_segment << character
-            position += 1
-          end
-          next
-        end
-
-        if inside_quoted_identifier
-          current_segment << character
-
-          if character == Constants::DOUBLE_QUOTE && sql[position + 1] == Constants::DOUBLE_QUOTE
-            position += 1
-            current_segment << sql[position]
-          elsif character == Constants::DOUBLE_QUOTE
-            inside_quoted_identifier = false
-          end
-
-          position += 1
-          next
-        end
-
-        if Tokenizer.sentinel_at?(sql, position)
-          end_position = Tokenizer.sentinel_end_position(sql, position)
-          current_segment << sql[position...end_position]
-          position = end_position
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        if consumed
+          current_segment << consumed
           next
         end
 
-        delimiter = Tokenizer.dollar_quote_delimiter_at(sql, position)
-
-        if delimiter
-          inside_dollar_quoted_string = true
-          dollar_quote_delimiter = delimiter
-          current_segment << delimiter
-          position += delimiter.length
-          next
-        end
+        character = scanner.current_char
 
         case character
-        when Constants::SINGLE_QUOTE
-          inside_string_literal = true
-          current_segment << character
-        when Constants::DOUBLE_QUOTE
-          inside_quoted_identifier = true
-          current_segment << character
         when Constants::OPEN_PARENTHESIS
-          parenthesis_depth += 1
+          scanner.increment_depth!
           current_segment << character
+
         when Constants::CLOSE_PARENTHESIS
-          parenthesis_depth = [parenthesis_depth - 1, 0].max
+          scanner.decrement_depth!
           current_segment << character
+
         when ";"
-          if parenthesis_depth.zero?
+          if scanner.parenthesis_depth.zero?
             stripped_segment = current_segment.strip
             segments << stripped_segment unless stripped_segment.empty?
             current_segment = +""
           else
             current_segment << character
           end
+
         else
           current_segment << character
         end
 
-        position += 1
+        scanner.advance!
       end
 
       stripped_segment = current_segment.strip
@@ -141,102 +81,54 @@ module SqlBeautifier
     end
 
     def detect_statement_boundaries(sql)
+      scanner = Scanner.new(sql)
       boundaries = []
       clause_seen = false
       current_statement_keyword = nil
-      inside_string_literal = false
-      inside_quoted_identifier = false
-      inside_dollar_quoted_string = false
-      dollar_quote_delimiter = nil
-      parenthesis_depth = 0
-      position = 0
-
-      while position < sql.length
-        character = sql[position]
-
-        if inside_string_literal
-          if character == Constants::SINGLE_QUOTE && sql[position + 1] == Constants::SINGLE_QUOTE
-            position += 2
-          else
-            inside_string_literal = false if character == Constants::SINGLE_QUOTE
-            position += 1
-          end
-          next
-        end
-
-        if inside_dollar_quoted_string
-          if sql[position, dollar_quote_delimiter.length] == dollar_quote_delimiter
-            position += dollar_quote_delimiter.length
-            inside_dollar_quoted_string = false
-            dollar_quote_delimiter = nil
-          else
-            position += 1
-          end
-          next
-        end
 
-        if inside_quoted_identifier
-          if character == Constants::DOUBLE_QUOTE && sql[position + 1] == Constants::DOUBLE_QUOTE
-            position += 2
-          else
-            inside_quoted_identifier = false if character == Constants::DOUBLE_QUOTE
-            position += 1
-          end
-          next
-        end
-
-        if Tokenizer.sentinel_at?(sql, position)
-          position = Tokenizer.sentinel_end_position(sql, position)
-          next
-        end
+      until scanner.finished?
+        next if scanner.skip_quoted_or_sentinel!
 
-        delimiter = Tokenizer.dollar_quote_delimiter_at(sql, position)
-
-        if delimiter
-          inside_dollar_quoted_string = true
-          dollar_quote_delimiter = delimiter
-          position += delimiter.length
-          next
-        end
-
-        case character
+        case scanner.current_char
         when Constants::SINGLE_QUOTE
-          inside_string_literal = true
+          scanner.enter_single_quote!
         when Constants::DOUBLE_QUOTE
-          inside_quoted_identifier = true
+          scanner.enter_double_quote!
         when Constants::OPEN_PARENTHESIS
-          parenthesis_depth += 1
+          scanner.increment_depth!
+          scanner.advance!
         when Constants::CLOSE_PARENTHESIS
-          parenthesis_depth = [parenthesis_depth - 1, 0].max
+          scanner.decrement_depth!
+          scanner.advance!
         else
-          if parenthesis_depth.zero?
-            matched_statement_keyword = keyword_match_at(sql, position, STATEMENT_KEYWORDS)
+          if scanner.parenthesis_depth.zero?
+            matched_statement_keyword = keyword_match_at(scanner, STATEMENT_KEYWORDS)
 
             if matched_statement_keyword
               if clause_seen && !continuation_keyword?(current_statement_keyword, matched_statement_keyword)
-                boundaries << position
+                boundaries << scanner.position
                 clause_seen = false
                 current_statement_keyword = matched_statement_keyword
               elsif boundaries.empty?
-                boundaries << position
+                boundaries << scanner.position
                 current_statement_keyword = matched_statement_keyword
               end
 
-              position += matched_statement_keyword.length
+              scanner.advance!(matched_statement_keyword.length)
               next
             end
 
-            matched_boundary_keyword = keyword_match_at(sql, position, BOUNDARY_KEYWORDS)
+            matched_boundary_keyword = keyword_match_at(scanner, BOUNDARY_KEYWORDS)
 
             if matched_boundary_keyword
               clause_seen = true
-              position += matched_boundary_keyword.length
+              scanner.advance!(matched_boundary_keyword.length)
               next
             end
           end
-        end
 
-        position += 1
+          scanner.advance!
+        end
       end
 
       boundaries
@@ -255,15 +147,15 @@ module SqlBeautifier
     end
 
     def sentinel_only?(segment)
-      segment.gsub(CommentStripper::SENTINEL_PATTERN, "").strip.empty?
+      segment.gsub(CommentParser::SENTINEL_PATTERN, "").strip.empty?
     end
 
     def continuation_keyword?(current_keyword, next_keyword)
       CONTINUATION_PAIRS[current_keyword] == next_keyword
     end
 
-    def keyword_match_at(sql, position, keywords)
-      keywords.detect { |keyword| Tokenizer.keyword_at?(sql, position, keyword) }
+    def keyword_match_at(scanner, keywords)
+      keywords.detect { |keyword| scanner.keyword_at?(keyword) }
     end
   end
 end

data/lib/sql_beautifier/table_reference.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class TableReference < Base
+    option :name
+    option :explicit_alias, default: -> {}
+    option :assigned_alias, default: -> {}
+
+    def self.parse(segment_text)
+      table_specification = table_specification_text(segment_text)
+      table_name = Util.first_word(table_specification)
+      return unless table_name
+
+      new(name: table_name, explicit_alias: extract_explicit_alias(table_specification))
+    end
+
+    def self.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 self.extract_explicit_alias(table_specification)
+      words = table_specification.strip.split(Constants::WHITESPACE_REGEX).grep_v(CommentParser::SENTINEL_PATTERN)
+      return nil if words.length < 2
+
+      if words[1] == "as"
+        words[2]
+      else
+        words[1]
+      end
+    end
+
+    def formatted_name
+      Util.format_table_name(@name)
+    end
+
+    def assign_alias!(value)
+      @assigned_alias = value
+    end
+
+    def alias_name
+      @explicit_alias || @assigned_alias
+    end
+
+    def render(trailing_sentinels: nil)
+      formatted = alias_name ? "#{formatted_name} #{alias_name}" : formatted_name
+      trailing_sentinels&.any? ? "#{formatted} #{trailing_sentinels.join(' ')}" : formatted
+    end
+  end
+end

data/lib/sql_beautifier/table_registry.rb

@@ -2,44 +2,51 @@
 
 module SqlBeautifier
   class TableRegistry
-    attr_reader :table_map
+    attr_reader :references
 
     def initialize(from_content)
       @from_content = from_content
-      @table_map = {}
       @alias_strategy = SqlBeautifier.config_for(:alias_strategy)
+      @references = []
+      @references_by_name = {}
       build!
     end
 
     def alias_for(table_name)
-      @table_map[table_name]
+      @references_by_name[table_name]&.alias_name
+    end
+
+    def reference_for(table_name)
+      @references_by_name[table_name]
+    end
+
+    def table_map
+      @references_by_name.transform_values(&:alias_name)
     end
 
     def apply_aliases(text)
-      return text if @table_map.empty?
+      return text if @references_by_name.empty?
 
+      scanner = Scanner.new(text)
       output = +""
-      position = 0
-
-      while position < text.length
-        character = text[position]
 
-        case character
+      until scanner.finished?
+        case scanner.current_char
         when Constants::SINGLE_QUOTE
-          position = copy_string_literal!(text, position, output)
+          output << scanner.consume_single_quoted_string!
         when Constants::DOUBLE_QUOTE
-          position = copy_quoted_identifier!(text, position, output)
+          output << scanner.consume_double_quoted_identifier!
         else
-          replacement = find_table_replacement_at(text, position)
+          replacement = find_table_replacement_at(text, scanner.position, scanner)
 
           if replacement
             table_name, table_alias = replacement
 
             output << "#{table_alias}."
-            position += table_name.length + 1
+            scanner.advance!(table_name.length + 1)
           else
-            output << character
-            position += 1
+            output << scanner.current_char
+            scanner.advance!
           end
         end
       end
@@ -50,51 +57,29 @@ module SqlBeautifier
     private
 
     def build!
-      table_entries = extract_table_entries(@from_content)
-
-      if @alias_strategy == :none
-        table_entries.each do |table_entry|
-          next unless table_entry[:explicit_alias]
-
-          @table_map[table_entry[:table_name]] = table_entry[:explicit_alias]
-        end
-      else
-        initials_occurrence_counts = count_initials_occurrences(table_entries)
-        used_aliases = []
-        assign_aliases!(table_entries, initials_occurrence_counts, used_aliases)
-      end
-
-      @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)
+      @references = parse_references(@from_content)
+      @references.each { |reference| @references_by_name[reference.name] = reference }
 
-      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
+      assign_computed_aliases! unless @alias_strategy == :none
 
-      occurrence_counts
+      aliased_names = @references_by_name.select { |_name, reference| reference.alias_name }.keys
+      @tables_by_descending_length = aliased_names.sort_by { |name| -name.length }.freeze
     end
 
-    def assign_aliases!(table_entries, initials_occurrence_counts, used_aliases)
+    def assign_computed_aliases!
+      initials_occurrence_counts = count_initials_occurrences
       duplicate_initials_counts = Hash.new(0)
       collision_counts = Hash.new(0)
+      used_aliases = []
 
-      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
+      @references.each do |reference|
+        if reference.explicit_alias
+          @references_by_name[reference.name] = reference
+          used_aliases << reference.explicit_alias
           next
         end
 
-        initials = table_initials(table_name)
+        initials = table_initials(reference.name)
         duplicate_initials_counts[initials] += 1 if initials_occurrence_counts[initials] > 1
 
         candidate_alias = begin
@@ -115,60 +100,30 @@ module SqlBeautifier
           end
         end
 
-        @table_map[table_name] = candidate_alias
+        reference.assign_alias!(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
+    def count_initials_occurrences
+      occurrence_counts = Hash.new(0)
 
-        if Tokenizer.escaped_double_quote?(text, position)
-          position += 1
-          output << text[position]
-        elsif character == Constants::DOUBLE_QUOTE
-          return position + 1
-        end
+      @references.each do |reference|
+        next if reference.explicit_alias
 
-        position += 1
+        occurrence_counts[table_initials(reference.name)] += 1
       end
 
-      position
+      occurrence_counts
     end
 
-    def find_table_replacement_at(text, position)
-      return unless Tokenizer.word_boundary?(Tokenizer.character_before(text, position))
+    def find_table_replacement_at(text, position, scanner)
+      return unless scanner.word_boundary?(scanner.character_before(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]]
+        return [table_name, @references_by_name[table_name].alias_name]
       end
 
       nil
@@ -180,50 +135,21 @@ module SqlBeautifier
       table_name.split("_").map { |segment| segment[0] }.join
     end
 
-    def extract_table_entries(from_content)
+    def parse_references(from_content)
       split_segments = from_content.strip.split(Constants::JOIN_KEYWORD_PATTERN)
 
-      table_entries = []
+      references = []
 
       primary_segment = split_segments.shift.strip
-      table_entries << extract_table_entry(primary_segment)
+      references << TableReference.parse(primary_segment)
 
       split_segments.each_slice(2) do |_join_keyword, join_content|
         next unless join_content
 
-        table_entries << extract_table_entry(join_content)
+        references << TableReference.parse(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).grep_v(CommentStripper::SENTINEL_PATTERN)
-      return nil if words.length < 2
-
-      if words[1] == "as"
-        words[2]
-      else
-        words[1]
-      end
+      references.compact
     end
   end
 end