ridgepole 0.9.6 → 1.0.2

data/bin/ridgepole

@@ -74,106 +74,104 @@ def noop_migrate(delta, options)
 end
 
 ARGV.options do |opt|
-  begin
-    opt.on('-c', '--config CONF_OR_FILE') { |v| config = v }
-    opt.on('-E', '--env ENVIRONMENT') { |v| env = v }
-    opt.on('-s', '--spec-name SPEC_NAME') { |v| spec_name = v }
-    opt.on('-a', '--apply') { set_mode[:apply] }
-    opt.on('-m', '--merge') do
-      set_mode[:apply]
-      options[:merge] = true
+  opt.on('-c', '--config CONF_OR_FILE') { |v| config = v }
+  opt.on('-E', '--env ENVIRONMENT') { |v| env = v }
+  opt.on('-s', '--spec-name SPEC_NAME') { |v| spec_name = v }
+  opt.on('-a', '--apply') { set_mode[:apply] }
+  opt.on('-m', '--merge') do
+    set_mode[:apply]
+    options[:merge] = true
+  end
+  opt.on('-f', '--file SCHEMAFILE') { |v| file = v }
+  opt.on('',   '--dry-run') { options[:dry_run] = true }
+  opt.on('',   '--table-options OPTIONS') { |v| options[:table_options] = v }
+  opt.on('',   '--table-hash-options OPTIONS') do |v|
+    # NOTE: Ruby2.4 doesn't support `symbolize_names: true`
+    hash = YAML.safe_load(v).deep_symbolize_keys
+
+    case hash[:id]
+    when String
+      hash[:id] = hash[:id].to_sym
+    when Hash
+      hash[:id][:type] = hash[:id][:type].to_sym if hash[:id][:type]
     end
-    opt.on('-f', '--file SCHEMAFILE') { |v| file = v }
-    opt.on('',   '--dry-run') { options[:dry_run] = true }
-    opt.on('',   '--table-options OPTIONS') { |v| options[:table_options] = v }
-    opt.on('',   '--table-hash-options OPTIONS') do |v|
-      # NOTE: Ruby2.4 doesn't support `symbolize_names: true`
-      hash = YAML.safe_load(v).deep_symbolize_keys
-
-      case hash[:id]
-      when String
-        hash[:id] = hash[:id].to_sym
-      when Hash
-        hash[:id][:type] = hash[:id][:type].to_sym if hash[:id][:type]
-      end
 
-      options[:table_hash_options] = hash
-    end
-    opt.on('',   '--alter-extra ALTER_SPEC') { |v| options[:alter_extra] = v }
-    opt.on('',   '--external-script SCRIPT') { |v| options[:external_script] = v }
-    opt.on('',   '--bulk-change') do
-      raise OptionParser::InvalidOption, 'Cannot use `bulk-change` in `merge`' if options[:merge]
+    options[:table_hash_options] = hash
+  end
+  opt.on('',   '--alter-extra ALTER_SPEC') { |v| options[:alter_extra] = v }
+  opt.on('',   '--external-script SCRIPT') { |v| options[:external_script] = v }
+  opt.on('',   '--bulk-change') do
+    raise OptionParser::InvalidOption, 'Cannot use `bulk-change` in `merge`' if options[:merge]
 
-      options[:bulk_change] = true
-    end
+    options[:bulk_change] = true
+  end
 
-    COLUMN_TYPES.each do |column_type, column_type_alias|
-      opt.on('', "--default-#{column_type_alias}-limit LIMIT", Integer) do |v|
-        options[:"default_#{column_type}_limit"] = v
-      end
+  COLUMN_TYPES.each do |column_type, column_type_alias|
+    opt.on('', "--default-#{column_type_alias}-limit LIMIT", Integer) do |v|
+      options[:"default_#{column_type}_limit"] = v
     end
+  end
 
-    opt.on('',   '--pre-query QUERY') { |v| options[:pre_query] = v }
-    opt.on('',   '--post-query QUERY') { |v| options[:post_query] = v }
-    opt.on('-e', '--export') { set_mode[:export] }
-    opt.on('',   '--split') { split = true }
-    opt.on('',   '--split-with-dir') { split = :with_dir }
-    opt.on('-d', '--diff DSL1 DSL2') do |diff_arg1|
-      set_mode[:diff]
-      diff_arg2 = ARGV.first
-
-      if [diff_arg1, diff_arg2].any? { |i| i.nil? || i.start_with?('-') }
-        puts opt.help
-        exit 1
-      end
+  opt.on('',   '--pre-query QUERY') { |v| options[:pre_query] = v }
+  opt.on('',   '--post-query QUERY') { |v| options[:post_query] = v }
+  opt.on('-e', '--export') { set_mode[:export] }
+  opt.on('',   '--split') { split = true }
+  opt.on('',   '--split-with-dir') { split = :with_dir }
+  opt.on('-d', '--diff DSL1 DSL2') do |diff_arg1|
+    set_mode[:diff]
+    diff_arg2 = ARGV.first
 
-      ARGV.shift
-      diff_files = [diff_arg1, diff_arg2]
-    end
-    opt.on('',   '--with-apply') { diff_with_apply = true }
-    opt.on('-o', '--output SCHEMAFILE') { |v| output_file = v }
-    opt.on('-t', '--tables TABLES', Array) { |v| options[:tables] = v }
-    opt.on('',   '--ignore-tables REGEX_LIST', Array) { |v| options[:ignore_tables] = v.map { |i| Regexp.new(i) } }
-    opt.on('',   '--dump-without-table-options') { options[:dump_without_table_options] = true }
-    opt.on('',   '--dump-with-default-fk-name') { options[:dump_with_default_fk_name] = true }
-    opt.on('',   '--index-removed-drop-column') { options[:index_removed_drop_column] = true }
-    opt.on('',   '--skip-drop-table') { options[:skip_drop_table] = true }
-    opt.on('',   '--mysql-change-table-options') { options[:mysql_change_table_options] = true }
-    opt.on('',   '--mysql-change-table-comment') { options[:mysql_change_table_comment] = true }
-    opt.on('',   '--check-relation-type DEF_PK') { |v| options[:check_relation_type] = v }
-    opt.on('',   '--ignore-table-comment') { options[:ignore_table_comment] = true }
-    opt.on('',   '--skip-column-comment-change') { options[:skip_column_comment_change] = true }
-    opt.on('',   '--allow-pk-change') { options[:allow_pk_change] = true }
-    opt.on('',   '--create-table-with-index') { options[:create_table_with_index] = true }
-
-    opt.on('',   '--mysql-dump-auto-increment') do
-      options[:mysql_dump_auto_increment] = true
+    if [diff_arg1, diff_arg2].any? { |i| i.nil? || i.start_with?('-') }
+      puts opt.help
+      exit 1
     end
 
-    opt.on('-r', '--require LIBS', Array) { |v| v.each { |i| require i } }
-    opt.on('', '--log-file LOG_FILE') { |v| options[:log_file] = v }
-    opt.on('', '--verbose') { Ridgepole::Logger.verbose = true }
-    opt.on('', '--debug') { options[:debug] = true }
-    opt.on('', '--[no-]color') { |v| options[:color] = v }
-
-    opt.on('-v', '--version') do
-      puts opt.ver
-      exit
-    end
+    ARGV.shift
+    diff_files = [diff_arg1, diff_arg2]
+  end
+  opt.on('',   '--with-apply') { diff_with_apply = true }
+  opt.on('-o', '--output SCHEMAFILE') { |v| output_file = v }
+  opt.on('-t', '--tables TABLES', Array) { |v| options[:tables] = v }
+  opt.on('',   '--ignore-tables REGEX_LIST', Array) { |v| options[:ignore_tables] = v.map { |i| Regexp.new(i) } }
+  opt.on('',   '--dump-without-table-options') { options[:dump_without_table_options] = true }
+  opt.on('',   '--dump-with-default-fk-name') { options[:dump_with_default_fk_name] = true }
+  opt.on('',   '--index-removed-drop-column') { options[:index_removed_drop_column] = true }
+  opt.on('',   '--drop-table') { options[:force_drop_table] = true }
+  opt.on('',   '--mysql-change-table-options') { options[:mysql_change_table_options] = true }
+  opt.on('',   '--mysql-change-table-comment') { options[:mysql_change_table_comment] = true }
+  opt.on('',   '--check-relation-type DEF_PK') { |v| options[:check_relation_type] = v }
+  opt.on('',   '--ignore-table-comment') { options[:ignore_table_comment] = true }
+  opt.on('',   '--skip-column-comment-change') { options[:skip_column_comment_change] = true }
+  opt.on('',   '--allow-pk-change') { options[:allow_pk_change] = true }
+  opt.on('',   '--create-table-with-index') { options[:create_table_with_index] = true }
+
+  opt.on('',   '--mysql-dump-auto-increment') do
+    options[:mysql_dump_auto_increment] = true
+  end
 
-    opt.parse!
+  opt.on('-r', '--require LIBS', Array) { |v| v.each { |i| require i } }
+  opt.on('', '--log-file LOG_FILE') { |v| options[:log_file] = v }
+  opt.on('', '--verbose') { Ridgepole::Logger.verbose = true }
+  opt.on('', '--debug') { options[:debug] = true }
+  opt.on('', '--[no-]color') { |v| options[:color] = v }
 
-    if !mode || (%i[apply export].include?(mode) && !config) || (options[:with_apply] && !config)
-      puts opt.help
-      exit 1
-    end
-  rescue StandardError => e
-    warn("[ERROR] #{e.message}")
+  opt.on('-v', '--version') do
+    puts opt.ver
+    exit
+  end
 
-    puts "\t" + e.backtrace.join("\n\t") unless e.is_a?(OptionParser::ParseError)
+  opt.parse!
 
+  if !mode || (%i[apply export].include?(mode) && !config) || (options[:with_apply] && !config)
+    puts opt.help
     exit 1
   end
+rescue StandardError => e
+  warn("[ERROR] #{e.message}")
+
+  puts "\t" + e.backtrace.join("\n\t") unless e.is_a?(OptionParser::ParseError)
+
+  exit 1
 end
 
 begin

data/docker-compose.yml

@@ -1,18 +1,26 @@
-mysql:
-  image: "mysql:5.6.38"
-  ports:
-    - "13316:3306"
-  environment:
-    MYSQL_ROOT_PASSWORD: password
-mysql57:
-  image: "mysql:5.7.20"
-  ports:
-    - "13317:3306"
-  environment:
-    MYSQL_ROOT_PASSWORD: password
-postgres:
-  image: "postgres:9.5"
-  ports:
-    - "15442:5432"
-  environment:
-    POSTGRES_PASSWORD: password
+version: "3.8"
+services:
+  mysql:
+    image: "mysql:5.6"
+    ports:
+      - "13316:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: password
+  mysql57:
+    image: "mysql:5.7"
+    ports:
+      - "13317:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: password
+  mysql80:
+    image: "mysql:8.0"
+    ports:
+      - "13318:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: password
+  postgres:
+    image: "postgres:14"
+    ports:
+      - "15442:5432"
+    environment:
+      POSTGRES_PASSWORD: password

data/gemfiles/activerecord_7.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 7.0.0"
+
+gemspec path: "../"

data/lib/ridgepole/client.rb

@@ -15,7 +15,12 @@ module Ridgepole
       @parser = Ridgepole::DSLParser.new(@options)
       @diff = Ridgepole::Diff.new(@options)
 
+      if Ridgepole::ConnectionAdapters.mysql?
+        require 'ridgepole/ext/abstract_mysql_adapter/partitioning'
+        require 'ridgepole/ext/abstract_mysql_adapter/schema_creation'
+      end
       require 'ridgepole/ext/abstract_mysql_adapter/dump_auto_increment' if @options[:mysql_dump_auto_increment]
+      require 'ridgepole/ext/postgresql_adapter/partitioning' if Ridgepole::ConnectionAdapters.postgresql?
     end
 
     def dump(&block)

data/lib/ridgepole/delta.rb

@@ -310,11 +310,29 @@ execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name
       append_change_table_options(table_name, comment_literal, buf)
     end
 
+    def append_change_partition(table_name, delta, buf)
+      (delta[:add] || {}).each do |_, attrs|
+        buf.puts "create_partition #{table_name.inspect}, **#{attrs.inspect}"
+      end
+    end
+
+    def append_change_partition_definitions(table_name, partition_definitions, buf, _post_buf_for_fk)
+      (partition_definitions[:add] || []).each do |partition_name, attrs|
+        buf.puts "add_partition #{table_name.inspect}, name: #{partition_name.inspect}, values: #{attrs[:values].inspect}"
+      end
+
+      (partition_definitions[:delete] || []).each do |partition_name, _attrs|
+        buf.puts "remove_partition #{table_name.inspect}, name: #{partition_name.inspect}"
+      end
+    end
+
     def append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)
       definition = attrs[:definition] || {}
       primary_key_definition = attrs[:primary_key_definition] || {}
       indices = attrs[:indices] || {}
       foreign_keys = attrs[:foreign_keys] || {}
+      partition = attrs[:partition] || {}
+      partition_definitions = attrs[:partition_definitions] || {}
       table_options = attrs[:table_options]
       table_charset = attrs[:table_charset]
       table_collation = attrs[:table_collation]
@@ -335,6 +353,10 @@ execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name
 
       append_change_table_comment(table_name, table_comment, buf) if table_comment
 
+      append_change_partition(table_name, partition, buf) unless partition.empty?
+
+      append_change_partition_definitions(table_name, partition_definitions, buf, post_buf_for_fk) unless partition_definitions.empty?
+
       buf.puts
       pre_buf_for_fk.puts
       post_buf_for_fk.puts

data/lib/ridgepole/diff.rb

@@ -37,11 +37,14 @@ module Ridgepole
           delta[:add] ||= {}
           delta[:add][table_name] = to_attrs
         end
+        delta[:change] ||= {}
+        delta[:change][table_name] ||= {}
+        scan_partition_change(table_name, from_attrs&.fetch(:partition, nil), to_attrs&.fetch(:partition, nil), delta[:change][table_name])
       end
 
       scan_relation_info(relation_info)
 
-      unless @options[:merge] || @options[:skip_drop_table]
+      if !@options[:merge] && @options[:force_drop_table]
         from.each do |table_name, from_attrs|
           next unless target?(table_name)
 
@@ -182,8 +185,8 @@ module Ridgepole
       to = to.except(*PRIMARY_KEY_OPTIONS)
 
       unless from == to
-        @logger.warn(<<-MSG)
-[WARNING] Table option changes are ignored on `#{table_name}`.
+        @logger.verbose_info(<<-MSG)
+# Table option changes are ignored on `#{table_name}`.
   from: #{from}
     to: #{to}
       MSG
@@ -419,6 +422,9 @@ module Ridgepole
             opts[:limit] = 4_294_967_295
           end
         end
+
+        # Workaround for Active Record 7.0
+        opts.delete(:precision) if attrs[:type] == :datetime && opts[:precision].nil?
       end
     end
 
@@ -609,6 +615,54 @@ module Ridgepole
       end
     end
 
+    def scan_partition_change(table_name, from, to, table_delta)
+      from = (from || {}).dup
+      to = (to || {}).dup
+      partition_delta = {}
+
+      return if to.empty? && from.empty?
+
+      if from.empty? && Ridgepole::ConnectionAdapters.mysql?
+        partition_delta[:add] ||= {}
+        partition_delta[:add][table_name] = to
+      else
+        if from.present? && (to[:type] != from[:type] || to[:columns] != from[:columns])
+          @logger.warn(<<-MSG)
+"[WARNING] '#{table_name}' partition is skipped because of the different partition type.
+  to: #{to[:type]} #{to[:columns]}
+  from: #{from[:type]}" #{from[:columns]}
+MSG
+          return
+        end
+
+        raise "All partition is different. please check partition settings.to:  #{to}, from: #{from}" if from[:partition_definitions].present? && (to[:partition_definitions] & from[:partition_definitions]).empty?
+
+        scan_partition_definition_chanage(from, to, table_delta)
+      end
+
+      table_delta[:partition] = partition_delta unless partition_delta.empty?
+    end
+
+    def scan_partition_definition_chanage(from, to, table_delta)
+      partition_definitions_delta = {}
+      attrs = { type: from[:type] || to[:type] }
+
+      from_partitions = (from[:partition_definitions] || []).index_by { |partition| partition[:name] }
+      to_partitions = (to[:partition_definitions] || []).index_by { |partition| partition[:name] }
+
+      (from_partitions.keys - to_partitions.keys).each do |name|
+        partition_definitions_delta[:delete] ||= {}
+        partition_definitions_delta[:delete][name] = attrs.merge(valuve: from_partitions[name][:values])
+      end
+
+      (to_partitions.keys - from_partitions.keys).each do |name|
+        partition_definitions_delta[:add] ||= {}
+        partition_definitions_delta[:add][name] = attrs.merge(values: to_partitions[name][:values])
+      end
+
+      table_delta[:partition_definitions] = partition_definitions_delta unless partition_definitions_delta.empty?
+    end
+
     def check_table_existence(definition)
       return unless @options[:tables]
 

data/lib/ridgepole/dsl_parser/context.rb

@@ -91,6 +91,22 @@ module Ridgepole
         }
       end
 
+      def add_partition(table_name, type, columns, partition_definitions: [])
+        partition_definitions.each do |partition_definition|
+          values = partition_definition.fetch(:values)
+          raise ArgumentError unless values.is_a?(Hash)
+
+          values[:in] = Array.wrap(values[:in]) if values.key?(:in)
+          values[:to] = Array.wrap(values[:to]) if values.key?(:to)
+          values[:from] = Array.wrap(values[:from]) if values.key?(:from)
+        end
+        @__definition[table_name][:partition] = {
+          type: type,
+          columns: Array.wrap(columns),
+          partition_definitions: partition_definitions,
+        }
+      end
+
       def require(file)
         schemafile = %r{\A/}.match?(file) ? file : File.join(@__working_dir, file)
 

data/lib/ridgepole/execute_expander.rb

@@ -13,7 +13,10 @@ module Ridgepole
     end
 
     module ConnectionAdapterExt
-      def execute(sql, name = nil)
+      def execute(*args)
+        sql = args.fetch(0)
+        name = args[1]
+
         if Ridgepole::ExecuteExpander.noop
           if (callback = Ridgepole::ExecuteExpander.callback)
             sql = append_alter_extra(sql)

data/lib/ridgepole/ext/abstract_adapter/partition_definition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PartitionDefinition
+      attr_reader :name, :values
+
+      def initialize(
+        name,
+        values
+      )
+        @name = name
+        @values = values
+      end
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_adapter/partition_options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PartitionOptions
+      attr_reader :table, :type, :columns, :partition_definitions
+
+      TYPES = %i[range list].freeze
+
+      def initialize(
+        table, type,
+        columns,
+        partition_definitions: []
+      )
+        @table = table
+        @type = type
+        @columns = Array.wrap(columns)
+        @partition_definitions = build_definitions(partition_definitions)
+      end
+
+      private
+
+      def build_definitions(definitions)
+        definitions.map do |definition|
+          next if definition.is_a?(PartitionDefinition)
+
+          PartitionDefinition.new(definition.fetch(:name), definition.fetch(:values))
+        end.compact
+      end
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_adapter/partitioning.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module Ridgepole
+  module Ext
+    module AbstractAdapter
+      module Partitioning
+        def partition(*)
+          nil
+        end
+
+        def partition_tables
+          []
+        end
+
+        # SchemaStatements
+        def create_partition(*)
+          raise NotImplementedError
+        end
+
+        def add_partition(*)
+          raise NotImplementedError
+        end
+
+        def remove_partition(*)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      prepend Ridgepole::Ext::AbstractAdapter::Partitioning
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_mysql_adapter/partitioning.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+
+module Ridgepole
+  module Ext
+    module AbstractMysqlAdapter
+      module Partitioning
+        def partition(table_name)
+          scope = quoted_scope(table_name)
+
+          partition_info = exec_query(<<~SQL, 'SCHEMA')
+            SELECT PARTITION_NAME, PARTITION_DESCRIPTION, PARTITION_METHOD, PARTITION_EXPRESSION
+            FROM information_schema.partitions
+            WHERE partition_name IS NOT NULL
+              AND table_schema = #{scope[:schema]}
+              AND table_name = #{scope[:name]}
+          SQL
+          return if partition_info.count == 0
+
+          type = case partition_info.first['PARTITION_METHOD']
+                 when 'LIST COLUMNS'
+                   :list
+                 when 'RANGE COLUMNS'
+                   :range
+                 else
+                   raise NotImplementedError, partition_info.first['PARTITION_METHOD'].to_s
+                 end
+          columns = partition_info.first['PARTITION_EXPRESSION'].delete('`').split(',').map(&:to_sym)
+
+          partition_definitions = partition_info.map do |row|
+            values = case type
+                     when :list
+                       { in: instance_eval("[#{row['PARTITION_DESCRIPTION'].gsub(/\(/, '[').gsub(/\)/, ']')}] # [1,2]", __FILE__, __LINE__) }
+                     when :range
+                       { to: instance_eval("[#{row['PARTITION_DESCRIPTION']}] # [1,2]", __FILE__, __LINE__) }
+                     else
+                       raise NotImplementedError
+                     end
+
+            { name: row['PARTITION_NAME'], values: values }
+          end
+
+          ActiveRecord::ConnectionAdapters::PartitionOptions.new(table_name, type, columns, partition_definitions: partition_definitions)
+        end
+
+        # SchemaStatements
+        def create_partition(table_name, type:, columns:, partition_definitions:)
+          execute schema_creation.accept(ActiveRecord::ConnectionAdapters::PartitionOptions.new(table_name, type, columns, partition_definitions: partition_definitions))
+        end
+
+        def add_partition(table_name, name:, values:)
+          pd = ActiveRecord::ConnectionAdapters::PartitionDefinition.new(name, values)
+          execute "ALTER TABLE #{quote_table_name(table_name)} ADD PARTITION (#{schema_creation.accept(pd)})"
+        end
+
+        def remove_partition(table_name, name:)
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP PARTITION #{name}"
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter < AbstractAdapter
+      prepend Ridgepole::Ext::AbstractMysqlAdapter::Partitioning
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/mysql/schema_creation'
+
+module Ridgepole
+  module Ext
+    module AbstractMysqlAdapter
+      module SchemaCreation
+        def visit_PartitionOptions(o)
+          sqls = o.partition_definitions.map { |partition_definition| accept partition_definition }
+          function = case o.type
+                     when :list
+                       "LIST COLUMNS(#{o.columns.map { |column| quote_column_name(column) }.join(',')})"
+                     when :range
+                       "RANGE COLUMNS(#{o.columns.map { |column| quote_column_name(column) }.join(',')})"
+                     else
+                       raise NotImplementedError
+                     end
+          "ALTER TABLE #{quote_table_name(o.table)} PARTITION BY #{function} (#{sqls.join(',')})"
+        end
+
+        def visit_PartitionDefinition(o)
+          if o.values.key?(:in)
+            "PARTITION #{o.name} VALUES IN (#{o.values[:in].map do |value|
+              value.is_a?(Array) ? "(#{value.map(&:inspect).join(',')})" : value.inspect
+            end.join(',')})"
+          elsif o.values.key?(:to)
+            "PARTITION #{o.name} VALUES LESS THAN (#{o.values[:to].map(&:inspect).join(',')})"
+          else
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaCreation
+        prepend Ridgepole::Ext::AbstractMysqlAdapter::SchemaCreation
+      end
+    end
+  end
+end