ridgepole 1.0.1 → 3.1.5

data/lib/ridgepole/delta.rb

@@ -4,6 +4,10 @@ module Ridgepole
   class Delta
     SCRIPT_NAME = '<Schema>'
 
+    RIDGEPOLE_OPTIONS = %i[
+      renamed_from
+    ].freeze
+
     def initialize(delta, options = {})
       @delta = delta
       @options = options
@@ -70,8 +74,8 @@ module Ridgepole
           ActiveRecord::Migration.disable_logging = true
           buf = StringIO.new
 
-          callback = proc do |sql, _name|
-            buf.puts sql if sql =~ /\A(CREATE|ALTER|DROP|RENAME)\b/i
+          callback = proc do |sql|
+            buf.puts sql if sql =~ /\A(CREATE|ALTER|DROP|RENAME|COMMENT)\b/i
           end
 
           eval_script_block = proc do
@@ -235,13 +239,39 @@ create_table(#{table_name.inspect}, #{inspect_options_include_default_proc(optio
         normalize_limit(column_type, column_options)
 
         buf.puts(<<-RUBY)
-  t.column(#{column_name.inspect}, :#{column_type.to_s.inspect}, #{inspect_options_include_default_proc(column_options)})
+  t.column(#{column_name.inspect}, :#{column_type.to_s.inspect}, #{inspect_options_include_default_proc(normalize_options(column_options))})
       RUBY
       end
 
-      if @options[:create_table_with_index] && !indices.empty?
-        indices.each do |index_name, index_attrs|
-          append_add_index(table_name, index_name, index_attrs, buf, true)
+      # Partition indices: indices referencing auto_increment columns must be
+      # inside CREATE TABLE on MySQL to avoid "must be defined as a key" error.
+      # cf. https://github.com/ridgepole/ridgepole/issues/494
+      if @options[:create_table_with_index]
+        indices_in_create = indices
+        indices_after_create = {}
+      else
+        indices_in_create, indices_after_create = partition_indices_for_create(definition, indices)
+      end
+
+      indices_in_create.each do |index_name, index_attrs|
+        append_add_index(table_name, index_name, index_attrs, buf, true)
+      end
+
+      unless (check_constraints = attrs[:check_constraints] || {}).empty?
+        check_constraints.each_value do |check_constraint_attrs|
+          append_add_check_constraint(table_name, check_constraint_attrs, buf, true)
+        end
+      end
+
+      unless (exclusion_constraints = attrs[:exclusion_constraints] || {}).empty?
+        exclusion_constraints.each_value do |exclusion_constraint_attrs|
+          append_add_exclusion_constraint(table_name, exclusion_constraint_attrs, buf, true)
+        end
+      end
+
+      unless (unique_constraints = attrs[:unique_constraints] || {}).empty?
+        unique_constraints.each_value do |unique_constraint_attrs|
+          append_add_unique_constraint(table_name, unique_constraint_attrs, buf, true)
         end
       end
 
@@ -249,16 +279,16 @@ create_table(#{table_name.inspect}, #{inspect_options_include_default_proc(optio
 end
       RUBY
 
-      if !(@options[:create_table_with_index]) && !indices.empty?
+      unless indices_after_create.empty?
         append_change_table(table_name, buf) do
-          indices.each do |index_name, index_attrs|
+          indices_after_create.each do |index_name, index_attrs|
             append_add_index(table_name, index_name, index_attrs, buf)
           end
         end
       end
 
       unless (foreign_keys = attrs[:foreign_keys] || {}).empty?
-        foreign_keys.each do |_, foreign_key_attrs|
+        foreign_keys.each_value do |foreign_key_attrs|
           append_add_foreign_key(table_name, foreign_key_attrs, post_buf_for_fk, @options)
         end
       end
@@ -267,6 +297,30 @@ end
       post_buf_for_fk.puts
     end
 
+    def partition_indices_for_create(definition, indices)
+      return [{}, indices] unless Ridgepole::ConnectionAdapters.mysql?
+
+      auto_increment_columns = definition.select do |_col_name, col_attrs|
+        col_attrs.dig(:options, :auto_increment)
+      end.keys
+
+      return [{}, indices] if auto_increment_columns.empty?
+
+      in_create = {}
+      after_create = {}
+
+      indices.each do |idx_name, idx_attrs|
+        columns = Array(idx_attrs[:column_name])
+        if (columns & auto_increment_columns).any?
+          in_create[idx_name] = idx_attrs
+        else
+          after_create[idx_name] = idx_attrs
+        end
+      end
+
+      [in_create, after_create]
+    end
+
     def append_rename_table(to_table_name, from_table_name, buf)
       buf.puts(<<-RUBY)
 rename_table(#{from_table_name.inspect}, #{to_table_name.inspect})
@@ -286,14 +340,14 @@ drop_table(#{table_name.inspect})
     def append_change_table_options(table_name, table_options, buf)
       # XXX: MySQL only
       buf.puts(<<-RUBY)
-execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{table_options}"
+execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{table_options.dump[1..-2]}"
     RUBY
 
       buf.puts
     end
 
     def append_change_table_raw_options(table_name, raw_table_options, table_charset, table_collation, buf)
-      if raw_table_options.blank? && ActiveRecord.gem_version >= Gem::Version.new('6.1.0')
+      if raw_table_options.blank?
         # Implicit engine is InnoDB in 6.1.0
         # related: https://github.com/rails/rails/pull/39365/files#diff-868f1dccfcbed26a288bf9f3fd8a39c863a4413ab0075e12b6805d9798f556d1R441
         raw_table_options = +'ENGINE=InnoDB'
@@ -306,8 +360,14 @@ execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name
     end
 
     def append_change_table_comment(table_name, table_comment, buf)
-      comment_literal = "COMMENT=#{ActiveRecord::Base.connection.quote(table_comment)}"
-      append_change_table_options(table_name, comment_literal, buf)
+      if Ridgepole::ConnectionAdapters.postgresql?
+        buf.puts(<<-RUBY)
+change_table_comment(#{table_name.inspect}, #{table_comment.inspect})
+        RUBY
+      else
+        comment_literal = "COMMENT=#{ActiveRecord::Base.connection.quote(table_comment)}"
+        append_change_table_options(table_name, comment_literal, buf)
+      end
     end
 
     def append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)
@@ -315,10 +375,14 @@ execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name
       primary_key_definition = attrs[:primary_key_definition] || {}
       indices = attrs[:indices] || {}
       foreign_keys = attrs[:foreign_keys] || {}
+      check_constraints = attrs[:check_constraints] || {}
+      exclusion_constraints = attrs[:exclusion_constraints] || {}
+      unique_constraints = attrs[:unique_constraints] || {}
       table_options = attrs[:table_options]
       table_charset = attrs[:table_charset]
       table_collation = attrs[:table_collation]
       table_comment = attrs[:table_comment]
+      column_comments = attrs[:column_comments] || {}
 
       if !definition.empty? || !indices.empty? || !primary_key_definition.empty?
         append_change_table(table_name, buf) do
@@ -330,16 +394,31 @@ execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name
       end
 
       append_change_foreign_keys(table_name, foreign_keys, pre_buf_for_fk, post_buf_for_fk, @options) unless foreign_keys.empty?
+      append_change_check_constraints(table_name, check_constraints, buf) unless check_constraints.empty?
+      append_change_exclusion_constraints(table_name, exclusion_constraints, buf) unless exclusion_constraints.empty?
+      append_change_unique_constraints(table_name, unique_constraints, buf) unless unique_constraints.empty?
 
-      append_change_table_raw_options(table_name, table_options, table_charset, table_collation, buf) if table_options || table_charset || table_collation
+      if table_options || table_charset || table_collation
+        append_change_table_raw_options(table_name, table_options, table_charset, table_collation,
+                                        buf)
+      end
 
       append_change_table_comment(table_name, table_comment, buf) if table_comment
+      append_change_column_comments(table_name, column_comments, buf) unless column_comments.empty?
 
       buf.puts
       pre_buf_for_fk.puts
       post_buf_for_fk.puts
     end
 
+    def append_change_column_comments(table_name, column_comments, buf)
+      column_comments.each do |column_name, comment|
+        buf.puts(<<-RUBY)
+change_column_comment(#{table_name.inspect}, #{column_name.inspect}, #{comment.inspect})
+        RUBY
+      end
+    end
+
     def append_change_table(table_name, buf)
       buf.puts "change_table(#{table_name.inspect}, bulk: true) do |t|" if @options[:bulk_change]
       yield
@@ -397,8 +476,15 @@ rename_column(#{table_name.inspect}, #{from_column_name.inspect}, #{to_column_na
       options = attrs[:options] || {}
 
       # Fix for https://github.com/rails/rails/commit/7f0567b43b73b1bd1a16bfac9cd32fcbf1321b51
-      if Ridgepole::ConnectionAdapters.mysql? && ActiveRecord::VERSION::STRING !~ /\A5\.0\./
+      if Ridgepole::ConnectionAdapters.mysql?
         options[:comment] = nil unless options.key?(:comment)
+
+        # Generated/virtual columns cannot have DEFAULT values in MySQL.
+        # cf. https://github.com/ridgepole/ridgepole/issues/482
+        if type == :virtual
+          options.delete(:default)
+          options.delete(:unsigned)
+        end
       end
 
       if @options[:bulk_change]
@@ -475,11 +561,11 @@ remove_index(#{table_name.inspect}, #{target})
     end
 
     def append_change_foreign_keys(table_name, delta, pre_buf_for_fk, post_buf_for_fk, options)
-      (delta[:delete] || {}).each do |_, attrs|
+      (delta[:delete] || {}).each_value do |attrs|
         append_remove_foreign_key(table_name, attrs, pre_buf_for_fk, options)
       end
 
-      (delta[:add] || {}).each do |_, attrs|
+      (delta[:add] || {}).each_value do |attrs|
         append_add_foreign_key(table_name, attrs, post_buf_for_fk, options)
       end
     end
@@ -508,6 +594,108 @@ remove_foreign_key(#{table_name.inspect}, #{target})
     RUBY
     end
 
+    def append_change_check_constraints(table_name, delta, buf)
+      (delta[:delete] || {}).each_value do |attrs|
+        append_remove_check_constraint(table_name, attrs, buf)
+      end
+
+      (delta[:add] || {}).each_value do |attrs|
+        append_add_check_constraint(table_name, attrs, buf)
+      end
+    end
+
+    def append_add_check_constraint(table_name, attrs, buf, force_bulk_change = false)
+      expression = attrs.fetch(:expression)
+      attrs_options = attrs[:options] || {}
+
+      if force_bulk_change
+        buf.puts(<<-RUBY)
+  t.check_constraint(#{expression.inspect}, **#{attrs_options.inspect})
+        RUBY
+      else
+        buf.puts(<<-RUBY)
+add_check_constraint(#{table_name.inspect}, #{expression.inspect}, **#{attrs_options.inspect})
+        RUBY
+      end
+    end
+
+    def append_remove_check_constraint(table_name, attrs, buf)
+      expression = attrs.fetch(:expression)
+      attrs_options = attrs[:options] || {}
+
+      buf.puts(<<-RUBY)
+remove_check_constraint(#{table_name.inspect}, #{expression.inspect}, **#{attrs_options.inspect})
+      RUBY
+    end
+
+    def append_change_exclusion_constraints(table_name, delta, buf)
+      (delta[:delete] || {}).each_value do |attrs|
+        append_remove_exclusion_constraint(table_name, attrs, buf)
+      end
+
+      (delta[:add] || {}).each_value do |attrs|
+        append_add_exclusion_constraint(table_name, attrs, buf)
+      end
+    end
+
+    def append_add_exclusion_constraint(table_name, attrs, buf, force_bulk_change = false)
+      expression = attrs.fetch(:expression)
+      attrs_options = attrs[:options] || {}
+
+      if force_bulk_change
+        buf.puts(<<-RUBY)
+  t.exclusion_constraint(#{expression.inspect}, **#{attrs_options.inspect})
+        RUBY
+      else
+        buf.puts(<<-RUBY)
+add_exclusion_constraint(#{table_name.inspect}, #{expression.inspect}, **#{attrs_options.inspect})
+        RUBY
+      end
+    end
+
+    def append_remove_exclusion_constraint(table_name, attrs, buf)
+      expression = attrs.fetch(:expression)
+      attrs_options = attrs[:options] || {}
+
+      buf.puts(<<-RUBY)
+remove_exclusion_constraint(#{table_name.inspect}, #{expression.inspect}, **#{attrs_options.inspect})
+      RUBY
+    end
+
+    def append_change_unique_constraints(table_name, delta, buf)
+      (delta[:delete] || {}).each_value do |attrs|
+        append_remove_unique_constraint(table_name, attrs, buf)
+      end
+
+      (delta[:add] || {}).each_value do |attrs|
+        append_add_unique_constraint(table_name, attrs, buf)
+      end
+    end
+
+    def append_add_unique_constraint(table_name, attrs, buf, force_bulk_change = false)
+      column_name = attrs.fetch(:column_name)
+      attrs_options = attrs[:options] || {}
+
+      if force_bulk_change
+        buf.puts(<<-RUBY)
+  t.unique_constraint(#{column_name.inspect}, **#{attrs_options.inspect})
+        RUBY
+      else
+        buf.puts(<<-RUBY)
+add_unique_constraint(#{table_name.inspect}, #{column_name.inspect}, **#{attrs_options.inspect})
+        RUBY
+      end
+    end
+
+    def append_remove_unique_constraint(table_name, attrs, buf)
+      column_name = attrs.fetch(:column_name)
+      attrs_options = attrs[:options] || {}
+
+      buf.puts(<<-RUBY)
+remove_unique_constraint(#{table_name.inspect}, #{column_name.inspect}, **#{attrs_options.inspect})
+      RUBY
+    end
+
     def delta_execute
       @delta[:execute] || []
     end
@@ -517,6 +705,12 @@ remove_foreign_key(#{table_name.inspect}, #{target})
       column_options[:limit] ||= default_limit if default_limit
     end
 
+    def normalize_options(options)
+      opts = options.dup
+      RIDGEPOLE_OPTIONS.each { opts.delete(_1) }
+      opts
+    end
+
     def inspect_options_include_default_proc(options)
       options = options.dup