sql_beautifier 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a22a4c99d49622a7631196a0622d66ebcfb81144bbd85238e854cf5fb7ad6d3
-  data.tar.gz: 685310c29776884c4164feeb272d6fdac9fb4e640df7272170ba6b0530ef10b4
+  metadata.gz: c4aaee15f7f4dc7c46c933893b8a02931c5fa83771707ccd22c092ec34ab859d
+  data.tar.gz: c059346ebc6f54814f8a7c9611ce768f022d8279631e0ca7f3234925f83a2f97
 SHA512:
-  metadata.gz: a4df9d20c0c4c92c6fe59ffbaa270ab82ed7356ffdb545d2055cae874d35c1f64347dd67971ac1260bfced3bf41cfd9dbf83bc77472ed5c1664b18772e4210c4
-  data.tar.gz: 26aebcef3cd11bc88dd898faee9d693bc72458e130ec814370c6163a903bbabb33c9cedd10cb40aadd5b7ea2f6ebc1edb42c0e8a21dc5471ca2a5c7ec0412c37
+  metadata.gz: b3717a14b1589c8aa1c8f14ffd046f68f385501c60f18ddb2b1330cde847189844d908600531b95b27a160dfebb4d0bb36b9044e25885e590f646a07e00b9f30
+  data.tar.gz: 52430c788c2ff7ebaf9da5e19c6cd5b1b73431e295fee2fed4b077ee36fabd9334bbbba6f8431c2020e6598bce6883f475cf3be624f898e9ff356b6aa1dff8ad

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.9.0] - 2026-03-29
+
+- Add DML statement formatting for `INSERT`, `UPDATE`, and `DELETE` — each statement type is routed to a dedicated entity class (`InsertQuery`, `UpdateQuery`, `DeleteQuery`) following the `Base` + `parse`/`render` pattern
+- Add `INSERT INTO ... VALUES` formatting with aligned column lists and multi-row value support
+- Add `INSERT INTO ... SELECT` formatting with automatic delegation of the SELECT portion to the existing formatter pipeline
+- Add `INSERT ... ON CONFLICT` and `INSERT ... RETURNING` clause support
+- Add `UPDATE ... SET` formatting with comma-separated assignment alignment and optional `FROM` and `WHERE` clauses
+- Add `DELETE FROM` formatting with optional `USING`, `WHERE`, and `RETURNING` clauses
+- Extract shared `render_where` and `render_returning` methods into `DmlRendering` module, included by `InsertQuery`, `UpdateQuery`, and `DeleteQuery`
+- Fix `InsertQuery` accepting malformed `VALUES` clause with no value tuples — empty rows from `scan_value_rows` are now treated as a parse failure
+- Fix `DeleteQuery` silently dropping table aliases (e.g. `DELETE FROM users u WHERE u.id = 1` rendered without the `u` alias, producing invalid SQL) — aliases (with or without `AS`) are now captured and included in the formatted output
+- Fix `DeleteQuery` mis-parsing `DELETE FROM ONLY <table>` — `ONLY` was read as the table name; the parser now bails out for unsupported modifiers
+- Fix `InsertQuery` silently dropping unrecognized trailing text after VALUES tuples (e.g. `VALUES (1) foo` would drop `foo`) — remaining text must start with `ON CONFLICT` or `RETURNING`, otherwise the parser bails out
+- Fix `DeleteQuery` silently dropping unrecognized text between table/alias and clause keywords — the parser now bails out when remaining text doesn't match any known clause
+
 ## [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

data/README.md

@@ -227,6 +227,135 @@ order by created_at desc
 limit 25;
 ```
 
+### INSERT
+
+`INSERT INTO ... VALUES` statements format with an indented column list and aligned value rows:
+
+```ruby
+SqlBeautifier.call(<<~SQL)
+  INSERT INTO users (id, name, email)
+  VALUES (1, 'Alice', 'alice@example.com'),
+         (2, 'Bob', 'bob@example.com')
+SQL
+```
+
+Produces:
+
+```sql
+insert into Users (
+    id,
+    name,
+    email
+)
+values  (1, 'Alice', 'alice@example.com'),
+        (2, 'Bob', 'bob@example.com');
+```
+
+`INSERT INTO ... SELECT` delegates the SELECT portion to the full formatter pipeline:
+
+```ruby
+SqlBeautifier.call("INSERT INTO users (id, name) SELECT id, name FROM temp_users WHERE active = true")
+```
+
+Produces:
+
+```sql
+insert into Users (
+    id,
+    name
+)
+
+select  id,
+        name
+
+from    Temp_Users tu
+
+where   active = true;
+```
+
+PostgreSQL `ON CONFLICT` and `RETURNING` clauses are supported:
+
+```ruby
+SqlBeautifier.call("INSERT INTO users (id, name) VALUES (1, 'Alice') ON CONFLICT (id) DO NOTHING RETURNING id")
+```
+
+Produces:
+
+```sql
+insert into Users (
+    id,
+    name
+)
+values  (1, 'Alice')
+on conflict (id) do nothing
+returning id;
+```
+
+### UPDATE
+
+`UPDATE ... SET` formats with aligned assignments and optional `FROM` and `WHERE` clauses:
+
+```ruby
+SqlBeautifier.call("UPDATE users SET name = 'Alice', email = 'alice@example.com' WHERE id = 1")
+```
+
+Produces:
+
+```sql
+update  Users
+set     name = 'Alice',
+        email = 'alice@example.com'
+where   id = 1;
+```
+
+PostgreSQL join-style `UPDATE ... FROM ... WHERE` is supported:
+
+```ruby
+SqlBeautifier.call("UPDATE users SET name = accounts.name FROM accounts WHERE users.account_id = accounts.id")
+```
+
+Produces:
+
+```sql
+update  Users
+set     name = accounts.name
+from    accounts
+where   users.account_id = accounts.id;
+```
+
+### DELETE
+
+`DELETE FROM` formats with standard clause layout:
+
+```ruby
+SqlBeautifier.call("DELETE FROM users WHERE status = 'inactive' AND last_login < '2024-01-01'")
+```
+
+Produces:
+
+```sql
+delete
+from    Users
+where   status = 'inactive'
+        and last_login < '2024-01-01';
+```
+
+PostgreSQL `USING` and `RETURNING` clauses are supported:
+
+```ruby
+SqlBeautifier.call("DELETE FROM users USING accounts WHERE users.account_id = accounts.id RETURNING users.id")
+```
+
+Produces:
+
+```sql
+delete
+from    Users
+using   accounts
+where   users.account_id = accounts.id
+returning users.id;
+```
+
 ### 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:

data/lib/sql_beautifier/delete_query.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class DeleteQuery < Base
+    include DmlRendering
+
+    option :table_name
+    option :table_alias, default: -> {}
+    option :using_clause, default: -> {}
+    option :where_clause, default: -> {}
+    option :returning_clause, default: -> {}
+    option :depth, default: -> { 0 }
+
+    def self.parse(normalized_sql, depth: 0)
+      scanner = Scanner.new(normalized_sql)
+      return nil unless scanner.keyword_at?("delete")
+
+      scanner.skip_past_keyword!("delete")
+
+      return nil unless scanner.keyword_at?("from")
+
+      scanner.skip_past_keyword!("from")
+      return nil if scanner.keyword_at?("only")
+
+      table_name = scanner.read_identifier!
+      return nil unless table_name
+
+      scanner.skip_whitespace!
+
+      table_alias = parse_table_alias(scanner)
+
+      remaining_text = normalized_sql[scanner.position..].strip
+      clauses = split_delete_clauses(normalized_sql, scanner.position)
+      return nil if remaining_text.present? && clauses.values.all?(&:nil?)
+
+      new(
+        table_name: table_name,
+        table_alias: table_alias,
+        using_clause: clauses[:using_clause],
+        where_clause: clauses[:where_clause],
+        returning_clause: clauses[:returning_clause],
+        depth: depth
+      )
+    end
+
+    def render
+      output = +""
+      output << render_delete
+      output << render_from
+      output << render_using if @using_clause
+      output << render_where if @where_clause
+      output << render_returning if @returning_clause
+
+      "#{output}\n"
+    end
+
+    def self.parse_table_alias(scanner)
+      return nil if scanner.finished?
+
+      next_keywords = %w[using where returning]
+      return nil if next_keywords.any? { |keyword| scanner.keyword_at?(keyword) }
+
+      scanner.skip_past_keyword!("as") if scanner.keyword_at?("as")
+
+      alias_name = scanner.read_identifier!
+      scanner.skip_whitespace! if alias_name
+
+      alias_name
+    end
+
+    def self.split_delete_clauses(normalized_sql, after_table_position)
+      remaining = normalized_sql[after_table_position..]
+      return {} unless remaining
+
+      using_position = Tokenizer.find_top_level_keyword(remaining, "using")
+      where_position = Tokenizer.find_top_level_keyword(remaining, "where")
+      returning_position = Tokenizer.find_top_level_keyword(remaining, "returning")
+
+      using_clause = nil
+      if using_position
+        using_end = [where_position, returning_position].compact.min || remaining.length
+        using_clause = remaining[(using_position + "using".length)...using_end].strip
+      end
+
+      where_clause = nil
+      if where_position
+        where_end = returning_position || remaining.length
+        where_clause = remaining[(where_position + "where".length)...where_end].strip
+      end
+
+      returning_clause = remaining[(returning_position + "returning".length)..].strip if returning_position
+
+      {
+        using_clause: using_clause.presence,
+        where_clause: where_clause.presence,
+        returning_clause: returning_clause.presence,
+      }
+    end
+
+    private_class_method :parse_table_alias, :split_delete_clauses
+
+    private
+
+    def render_delete
+      Util.format_keyword("delete")
+    end
+
+    def render_from
+      table_reference = Util.format_table_name(@table_name)
+      table_reference = "#{table_reference} #{@table_alias}" if @table_alias
+
+      "\n#{Util.keyword_padding('from')}#{table_reference}"
+    end
+
+    def render_using
+      "\n#{Util.keyword_padding('using')}#{@using_clause}"
+    end
+  end
+end

data/lib/sql_beautifier/dml_rendering.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module DmlRendering
+    private
+
+    def render_where
+      keyword_column_width = SqlBeautifier.config_for(:keyword_column_width)
+      conditions = Condition.parse_all(@where_clause)
+
+      return "\n#{Util.keyword_padding('where')}#{@where_clause.strip}" if conditions.length <= 1 && conditions.first&.leaf?
+
+      formatted_conditions = Condition.render_all(conditions, indent_width: keyword_column_width)
+
+      "\n#{formatted_conditions.sub(Util.continuation_padding, Util.keyword_padding('where'))}"
+    end
+
+    def render_returning
+      "\n#{Util.keyword_padding('returning')}#{@returning_clause}"
+    end
+  end
+end

data/lib/sql_beautifier/formatter.rb

@@ -32,6 +32,15 @@ module SqlBeautifier
       compound_result = CompoundQuery.parse(@normalized_value, depth: @depth)&.render
       return prepend_sentinels(compound_result) if compound_result
 
+      insert_result = InsertQuery.parse(@normalized_value, depth: @depth)&.render
+      return prepend_sentinels(insert_result) if insert_result
+
+      update_result = UpdateQuery.parse(@normalized_value, depth: @depth)&.render
+      return prepend_sentinels(update_result) if update_result
+
+      delete_result = DeleteQuery.parse(@normalized_value, depth: @depth)&.render
+      return prepend_sentinels(delete_result) if delete_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/insert_query.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class InsertQuery < Base
+    include DmlRendering
+
+    option :table_name
+    option :column_list, default: -> {}
+    option :values_rows, default: -> {}
+    option :select_sql, default: -> {}
+    option :on_conflict_clause, default: -> {}
+    option :returning_clause, default: -> {}
+    option :depth, default: -> { 0 }
+
+    def self.parse(normalized_sql, depth: 0)
+      scanner = Scanner.new(normalized_sql)
+      return nil unless scanner.keyword_at?("insert")
+
+      scanner.skip_past_keyword!("insert")
+      return nil unless scanner.keyword_at?("into")
+
+      scanner.skip_past_keyword!("into")
+
+      table_name = scanner.read_identifier!
+      return nil unless table_name
+
+      scanner.skip_whitespace!
+
+      column_list = parse_column_list(normalized_sql, scanner)
+      values_rows, select_sql, on_conflict_clause, returning_clause = parse_body(normalized_sql, scanner)
+
+      return nil unless values_rows || select_sql
+
+      new(
+        table_name: table_name,
+        column_list: column_list,
+        values_rows: values_rows,
+        select_sql: select_sql,
+        on_conflict_clause: on_conflict_clause,
+        returning_clause: returning_clause,
+        depth: depth
+      )
+    end
+
+    def render
+      output = +""
+      output << render_insert_into
+      output << render_column_list if @column_list
+      output << render_values if @values_rows
+      output << render_select if @select_sql
+      output << render_on_conflict if @on_conflict_clause
+      output << render_returning if @returning_clause
+
+      "#{output}\n"
+    end
+
+    def self.parse_column_list(normalized_sql, scanner)
+      return nil unless scanner.position < normalized_sql.length && scanner.current_char == Constants::OPEN_PARENTHESIS
+
+      closing = scanner.find_matching_parenthesis(scanner.position)
+      return nil unless closing
+
+      inner_text = normalized_sql[(scanner.position + 1)...closing].strip
+      scanner.advance!(closing + 1 - scanner.position)
+      scanner.skip_whitespace!
+
+      return nil if inner_text.empty?
+
+      inner_text
+    end
+
+    def self.parse_body(normalized_sql, scanner)
+      remaining = normalized_sql[scanner.position..].strip
+      scanner.advance!(normalized_sql.length - scanner.position)
+
+      values_rows = nil
+      select_sql = nil
+      on_conflict_clause = nil
+      returning_clause = nil
+
+      remaining_scanner = Scanner.new(remaining)
+
+      if remaining_scanner.keyword_at?("values")
+        remaining_scanner.skip_past_keyword!("values")
+        values_text = remaining[remaining_scanner.position..].strip
+        values_rows, on_conflict_clause, returning_clause = split_values_tail(values_text)
+      elsif remaining_scanner.keyword_at?("select")
+        select_sql, on_conflict_clause, returning_clause = split_select_tail(remaining)
+      end
+
+      [values_rows, select_sql, on_conflict_clause, returning_clause]
+    end
+
+    def self.split_values_tail(values_text)
+      rows, remaining_text = scan_value_rows(values_text)
+      return [nil, nil, nil] if rows.empty?
+
+      on_conflict_clause = nil
+      returning_clause = nil
+
+      if remaining_text.present?
+        normalized_remaining = remaining_text.lstrip.downcase
+        return [nil, nil, nil] unless normalized_remaining.start_with?("on conflict", "returning")
+
+        on_conflict_clause, returning_clause = split_on_conflict_and_returning(remaining_text)
+      end
+
+      [rows, on_conflict_clause, returning_clause]
+    end
+
+    def self.scan_value_rows(values_text)
+      scanner = Scanner.new(values_text)
+      rows = []
+
+      until scanner.finished?
+        scanner.skip_whitespace!
+        break if scanner.finished?
+        break unless scanner.current_char == Constants::OPEN_PARENTHESIS
+
+        closing = scanner.find_matching_parenthesis(scanner.position)
+        break unless closing
+
+        rows << values_text[scanner.position..(closing)]
+        scanner.advance!(closing + 1 - scanner.position)
+        scanner.skip_whitespace!
+
+        break unless !scanner.finished? && scanner.current_char == Constants::COMMA
+
+        scanner.advance!
+      end
+
+      remaining_text = values_text[scanner.position..].strip
+
+      [rows, remaining_text]
+    end
+
+    def self.split_select_tail(remaining)
+      on_conflict_position = find_top_level_keyword_position(remaining, "on conflict")
+      returning_position = find_top_level_keyword_position(remaining, "returning")
+
+      end_of_select = [on_conflict_position, returning_position].compact.min || remaining.length
+      select_sql = remaining[0...end_of_select].strip
+
+      on_conflict_clause = nil
+      returning_clause = nil
+
+      if on_conflict_position
+        on_conflict_end = returning_position || remaining.length
+        on_conflict_clause = remaining[on_conflict_position...on_conflict_end].strip
+      end
+
+      returning_clause = remaining[(returning_position + "returning".length)..].strip if returning_position
+
+      [select_sql, on_conflict_clause, returning_clause]
+    end
+
+    def self.split_on_conflict_and_returning(text)
+      on_conflict_position = find_top_level_keyword_position(text, "on conflict")
+      returning_position = find_top_level_keyword_position(text, "returning")
+
+      on_conflict_clause = nil
+      returning_clause = nil
+
+      if on_conflict_position
+        on_conflict_end = returning_position || text.length
+        on_conflict_clause = text[on_conflict_position...on_conflict_end].strip
+      end
+
+      returning_clause = text[(returning_position + "returning".length)..].strip if returning_position
+
+      [on_conflict_clause, returning_clause]
+    end
+
+    def self.find_top_level_keyword_position(text, keyword)
+      Tokenizer.find_top_level_keyword(text, keyword)
+    end
+
+    private_class_method :parse_column_list, :parse_body, :split_values_tail, :scan_value_rows, :split_select_tail, :split_on_conflict_and_returning, :find_top_level_keyword_position
+
+    private
+
+    def render_insert_into
+      "#{Util.keyword_padding('insert into')}#{Util.format_table_name(@table_name)}"
+    end
+
+    def render_column_list
+      columns = Tokenizer.split_by_top_level_commas(@column_list)
+      indent = Util.whitespace(SqlBeautifier.config_for(:indent_spaces) || 4)
+
+      formatted_columns = columns.map { |column| "#{indent}#{column.strip}" }.join(",\n")
+
+      " (\n#{formatted_columns}\n)"
+    end
+
+    def render_values
+      continuation = Util.continuation_padding
+
+      formatted_rows = @values_rows.map.with_index do |row, index|
+        if index.zero?
+          "#{Util.keyword_padding('values')}#{row}"
+        else
+          "#{continuation}#{row}"
+        end
+      end
+
+      "\n#{formatted_rows.join(",\n")}"
+    end
+
+    def render_select
+      formatted_select = Formatter.new(@select_sql, depth: @depth).call
+      return "" unless formatted_select
+
+      "\n\n#{formatted_select.chomp}"
+    end
+
+    def render_on_conflict
+      "\n#{@on_conflict_clause}"
+    end
+  end
+end

data/lib/sql_beautifier/update_query.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class UpdateQuery < Base
+    include DmlRendering
+
+    option :table_name
+    option :assignments
+    option :from_clause, default: -> {}
+    option :where_clause, default: -> {}
+    option :returning_clause, default: -> {}
+    option :depth, default: -> { 0 }
+
+    def self.parse(normalized_sql, depth: 0)
+      scanner = Scanner.new(normalized_sql)
+      return nil unless scanner.keyword_at?("update")
+
+      scanner.skip_past_keyword!("update")
+
+      table_name = scanner.read_identifier!
+      return nil unless table_name
+
+      scanner.skip_whitespace!
+      return nil unless scanner.keyword_at?("set")
+
+      scanner.skip_past_keyword!("set")
+
+      clauses = split_update_clauses(normalized_sql, scanner.position)
+      return nil unless clauses[:assignments]
+
+      new(
+        table_name: table_name,
+        assignments: clauses[:assignments],
+        from_clause: clauses[:from_clause],
+        where_clause: clauses[:where_clause],
+        returning_clause: clauses[:returning_clause],
+        depth: depth
+      )
+    end
+
+    def render
+      output = +""
+      output << render_update
+      output << render_assignments
+      output << render_from if @from_clause
+      output << render_where if @where_clause
+      output << render_returning if @returning_clause
+
+      "#{output}\n"
+    end
+
+    def self.split_update_clauses(normalized_sql, set_content_start)
+      remaining = normalized_sql[set_content_start..]
+
+      from_position = Tokenizer.find_top_level_keyword(remaining, "from")
+      where_position = Tokenizer.find_top_level_keyword(remaining, "where")
+      returning_position = Tokenizer.find_top_level_keyword(remaining, "returning")
+
+      assignments_end = [from_position, where_position, returning_position].compact.min || remaining.length
+      assignments_text = remaining[0...assignments_end].strip
+
+      from_clause = nil
+      if from_position
+        from_end = [where_position, returning_position].compact.min || remaining.length
+        from_clause = remaining[(from_position + "from".length)...from_end].strip
+      end
+
+      where_clause = nil
+      if where_position
+        where_end = returning_position || remaining.length
+        where_clause = remaining[(where_position + "where".length)...where_end].strip
+      end
+
+      returning_clause = remaining[(returning_position + "returning".length)..].strip if returning_position
+
+      {
+        assignments: assignments_text.presence,
+        from_clause: from_clause.presence,
+        where_clause: where_clause.presence,
+        returning_clause: returning_clause.presence,
+      }
+    end
+
+    private_class_method :split_update_clauses
+
+    private
+
+    def render_update
+      "#{Util.keyword_padding('update')}#{Util.format_table_name(@table_name)}"
+    end
+
+    def render_assignments
+      items = Tokenizer.split_by_top_level_commas(@assignments)
+      continuation = Util.continuation_padding
+
+      formatted_items = items.map.with_index do |item, index|
+        if index.zero?
+          "\n#{Util.keyword_padding('set')}#{item.strip}"
+        else
+          "\n#{continuation}#{item.strip}"
+        end
+      end
+
+      formatted_items.join(",")
+    end
+
+    def render_from
+      "\n#{Util.keyword_padding('from')}#{@from_clause}"
+    end
+  end
+end

data/lib/sql_beautifier/version.rb

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

data/lib/sql_beautifier.rb

@@ -25,6 +25,10 @@ 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/dml_rendering"
+require_relative "sql_beautifier/insert_query"
+require_relative "sql_beautifier/update_query"
+require_relative "sql_beautifier/delete_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.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -84,8 +84,11 @@ files:
 - lib/sql_beautifier/create_table_as.rb
 - lib/sql_beautifier/cte_definition.rb
 - lib/sql_beautifier/cte_query.rb
+- lib/sql_beautifier/delete_query.rb
+- lib/sql_beautifier/dml_rendering.rb
 - lib/sql_beautifier/expression.rb
 - lib/sql_beautifier/formatter.rb
+- lib/sql_beautifier/insert_query.rb
 - lib/sql_beautifier/join.rb
 - lib/sql_beautifier/normalizer.rb
 - lib/sql_beautifier/query.rb
@@ -97,6 +100,7 @@ files:
 - lib/sql_beautifier/table_registry.rb
 - lib/sql_beautifier/tokenizer.rb
 - lib/sql_beautifier/types.rb
+- lib/sql_beautifier/update_query.rb
 - lib/sql_beautifier/util.rb
 - lib/sql_beautifier/version.rb
 homepage: https://github.com/kinnell/sql_beautifier