ridgepole 1.0.7 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7886d7c158b4776c9db77e73c72ab5d882241950ed6a9f2c945a99220b7bcc4a
-  data.tar.gz: 6429c8b8ed0c17dd1361c0e01592180c521002fa64fead1e625e9ec7ab2436a9
+  metadata.gz: 5906641e6a784f8548801ef9b94acedf8580ce9f5fcf2d8c23640b29968d9a65
+  data.tar.gz: fcbbf42e5eba4bfa9d16f8ba813d5c2374c357265a96bbf0322a66b84c17b99b
 SHA512:
-  metadata.gz: a7a06ba181dbdad2e0dd6f054366d745a3dbd119715bdb83b9a5e440c8a2258014859b2f9a8916b75fd5fb0ed9c27c4a32efe7d51761d7dd62a5e313cbad6fae
-  data.tar.gz: '0277821bd5e0fc9c47ec038bf938a1b1a8c18c8395af8fd5ccfdf14ed9a8b80b03c5b6550f7b11d4da7220023be6e14782261a0a85f5b70ad7d136561bce4724'
+  metadata.gz: 8eab1b038598d76ad94806aeeeda51af292527fa9ca84cecbc9be8b28b8351225c80782069824c7f7ca8619cdbacb7f85a9c29ef647e783a5d850957273d5f25
+  data.tar.gz: 834667f47a46455e1969574fb2341d620742e119c8882e70dc7d30c29c5780bf2671698f9982dbfed7a99cfc61f29344e7bffc0ec654c6f161d37af8189e4531

data/.rubocop.yml

@@ -30,12 +30,6 @@ Metrics/ParameterLists:
   Enabled: false
 Metrics/PerceivedComplexity:
   Enabled: false
-Naming/MethodName:
-  Exclude:
-    - "lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb"
-Naming/MethodParameterName:
-  Exclude:
-    - "lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb"
 Style/Documentation:
   Enabled: false
 Style/GuardClause:

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## 1.0
 
+### 1.1.0 (2022/06/18)
+
+* Revert partitioning support [pull#392](https://github.com/ridgepole/ridgepole/pull/392)
+
+## 1.0
+
 ### 1.0.7 (2022/06/09)
 
 * Normalize list partition values for PostgreSQL [pull#389](https://github.com/ridgepole/ridgepole/pull/389)

data/README.md

@@ -11,6 +11,7 @@ It defines DB schema using [Rails DSL](http://guides.rubyonrails.org/migrations.
 
 **Notice**
 
+* Partitioning is no longer supported in ridgepole v1.1.0.
 * ActiveRecord 7.x has some incompatible changes. If you get unintended differences in `datetime`, add `precision`.
   * cf. https://github.com/ridgepole/ridgepole/issues/381
 * For ActiveRecord 7.x series, please use AcriveRecord 7.0.2 or higher / Ridgepole 1.0.3 or higher.
@@ -216,7 +217,7 @@ See `mysql> show character set;` to find charset / collation pair for your syste
 
 ## Generated Column (MySQL)
 
-There should be NO extra white spaces in the expression (such as after comma).  
+There should be NO extra white spaces in the expression (such as after comma).
 Quotes in expression may cause the operations failure with MySQL 8.0.
 
 ```ruby
@@ -318,31 +319,6 @@ Apply `Schemafile`
 ...
 ```
 
-## Partitioning
-
-**Notice:** PostgreSQL `PARTITION BY` must be specified with the create_table option.
-
-### List Partitioning
-
-```ruby
-create_table "articles", force: :cascade, options: "PARTITION BY LIST(id)" do |t|
-end
-
-add_partition("articles", :list, :id, partition_definitions: [{ name: 'p0', values: { in: [0,1,2] } }, { name: 'p1', values: { in: [3,4,5] } }])
-```
-
-### Range Partitioning
-
-```ruby
-create_table "articles", force: :cascade, options: "PARTITION BY RANGE(id)" do |t|
-end
-
-# postgresql
-add_partition("articles", :range, :id, partition_definitions: [{ name: 'p0', values: { from: 'MINVALUE', to: 5 }}, { name: 'p1', values: { from: 5, to: 10 } }])
-# mysql
-add_partition("articles", :range, :id, partition_definitions: [{ name: 'p0', values: { to: 5 }}, { name: 'p1', values: { to: 10 } }])
-```
-
 ## Run tests
 
 

data/lib/ridgepole/client.rb

@@ -15,12 +15,7 @@ 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,29 +310,11 @@ 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]
@@ -356,10 +338,6 @@ 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,9 +37,6 @@ 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)
@@ -620,56 +617,6 @@ 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
-
-        if from[:partition_definitions].present? && (to[:partition_definitions] & from[:partition_definitions]).empty?
-          raise "All partition is different. please check partition settings.to:  #{to}, from: #{from}"
-        end
-
-        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(values: 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,25 +91,6 @@ 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)
-
-          if values.key?(:in)
-            values[:in] = Array.wrap(values[:in])
-            values[:in] = values[:in].map(&:to_s) if Ridgepole::ConnectionAdapters.postgresql?
-          end
-          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/ext/schema_dumper.rb

@@ -45,30 +45,6 @@ module Ridgepole
           stream.puts add_foreign_key_statements.sort.join("\n")
         end
       end
-
-      def tables(stream)
-        original = ignore_tables.dup
-        ignore_tables.concat(@connection.partition_tables)
-        super
-      ensure
-        self.ignore_tables = original
-      end
-
-      def table(table, stream)
-        super
-        partition(table, stream)
-      end
-
-      def partition(table, stream)
-        if (partition = @connection.partition(table))
-          partition_definitions = partition.partition_definitions.map do |partition_definition|
-            "{ name: #{partition_definition.name.inspect}, values: #{partition_definition.values} }"
-          end.join(' ,')
-
-          stream.puts "  add_partition #{partition.table.inspect}, #{partition.type.inspect}, #{partition.columns.inspect}, partition_definitions: [#{partition_definitions}]"
-          stream.puts
-        end
-      end
     end
   end
 end

data/lib/ridgepole/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ridgepole
-  VERSION = '1.0.7'
+  VERSION = '1.1.0'
 end

data/lib/ridgepole.rb

@@ -16,9 +16,6 @@ require 'diffy'
 module Ridgepole; end
 
 require 'ridgepole/ext/abstract_adapter/disable_table_options'
-require 'ridgepole/ext/abstract_adapter/partition_definition'
-require 'ridgepole/ext/abstract_adapter/partition_options'
-require 'ridgepole/ext/abstract_adapter/partitioning'
 require 'ridgepole/ext/pp_sort_hash'
 require 'ridgepole/ext/schema_dumper'
 require 'ridgepole/client'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ridgepole
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.1.0
 platform: ruby
 authors:
 - Genki Sugawara
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-08 00:00:00.000000000 Z
+date: 2022-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -306,13 +306,7 @@ files:
 - lib/ridgepole/dumper.rb
 - lib/ridgepole/execute_expander.rb
 - lib/ridgepole/ext/abstract_adapter/disable_table_options.rb
-- lib/ridgepole/ext/abstract_adapter/partition_definition.rb
-- lib/ridgepole/ext/abstract_adapter/partition_options.rb
-- lib/ridgepole/ext/abstract_adapter/partitioning.rb
 - lib/ridgepole/ext/abstract_mysql_adapter/dump_auto_increment.rb
-- lib/ridgepole/ext/abstract_mysql_adapter/partitioning.rb
-- lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb
-- lib/ridgepole/ext/postgresql_adapter/partitioning.rb
 - lib/ridgepole/ext/pp_sort_hash.rb
 - lib/ridgepole/ext/schema_dumper.rb
 - lib/ridgepole/external_sql_executer.rb

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

@@ -1,19 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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

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

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_record/connection_adapters/postgresql_adapter'
-
-module Ridgepole
-  module Ext
-    module PostgreSQLAdapter
-      module Partitioning
-        def supports_partitions?
-          ActiveRecord::VERSION::MAJOR >= 6 && postgresql_version >= 100_000 # >= 10.0
-        end
-
-        def table_options(table_name)
-          options = partition_options(table_name)
-          if options
-            (super || {}).merge(options: "PARTITION BY #{options[:type].to_s.upcase}(#{options[:columns].join(',')})")
-          else
-            super
-          end
-        end
-
-        def partition_options(table_name)
-          return unless supports_partitions?
-
-          scope = quoted_scope(table_name)
-          result = query_value(<<~SQL, 'SCHEMA')
-            SELECT pg_get_partkeydef(t.oid)
-            FROM pg_class t
-              LEFT JOIN pg_namespace n ON n.oid = t.relnamespace
-            WHERE t.relname = #{scope[:name]}
-              AND n.nspname = #{scope[:schema]}
-          SQL
-          return unless result
-
-          type, *columns = result.scan(/\w+/).map { |value| value.downcase.to_sym }
-          { type: type, columns: columns }
-        end
-
-        def partition(table_name)
-          options = partition_options(table_name)
-          return unless options
-
-          scope = quoted_scope(table_name)
-          partition_info = query(<<~SQL, 'SCHEMA')
-            SELECT p.relname, pg_get_expr(p.relpartbound, p.oid, true)
-            FROM pg_class t
-            JOIN pg_inherits i on i.inhparent = t.oid
-            JOIN pg_class p on p.oid = i.inhrelid
-            WHERE t.relname = #{scope[:name]}
-              AND p.relnamespace::regnamespace::text = #{scope[:schema]}
-            ORDER BY p.relname
-          SQL
-
-          partition_definitions = partition_info.map do |name, val_str|
-            values = if val_str == 'DEFAULT'
-                       { default: true }
-                     else
-                       case options[:type]
-                       when :list
-                         values = val_str.match(/FOR VALUES IN \((?<csv>.+)\)$/)[:csv].split(',').map(&:strip).map { |value| cast_value(value) }
-                         { in: Array.wrap(values) }
-                       when :range
-                         match = val_str.match(/FOR VALUES FROM \((?<from>.+)\) TO \((?<to>.+)\)/)
-                         from = match[:from].split(',').map(&:strip).map { |value| cast_value(value) }
-                         to = match[:to].split(',').map(&:strip).map { |value| cast_value(value) }
-                         { from: from, to: to }
-                       when :hash
-                         match = val_str.match(/FOR VALUES WITH \(modulus (?<modulus>\d+), remainder (?<remainder>\d+)\)/)
-                         { modulus: match[:modulus].to_i, remainder: match[:remainder].to_i }
-                       else
-                         raise NotImplementedError
-                       end
-                     end
-            { name: name, values: values }
-          end
-
-          ActiveRecord::ConnectionAdapters::PartitionOptions.new(table_name, options[:type], options[:columns],
-                                                                 partition_definitions: partition_definitions)
-        end
-
-        def cast_value(value)
-          Integer(value)
-        rescue ArgumentError
-          value.delete(%q("')) # "
-        end
-
-        def quote_value(value)
-          if %w[MINVALUE MAXVALUE].include?(value)
-            value
-          else
-            quote(value)
-          end
-        end
-
-        def partition_tables
-          partition_info = query(<<~SQL, 'SCHEMA')
-            SELECT p.relname
-            FROM pg_class t
-            JOIN pg_inherits i on i.inhparent = t.oid
-            JOIN pg_class p on p.oid = i.inhrelid
-            ORDER BY p.relname
-          SQL
-          partition_info.map { |row| row[0] }
-        end
-
-        # SchemaStatements
-        def add_partition(table_name, name:, values:)
-          condition = if values.key?(:default)
-                        'DEFAULT'
-                      elsif values.key?(:in)
-                        "FOR VALUES IN (#{values[:in].map { |v| quote_value(v) }.join(',')})"
-                      elsif values.key?(:to)
-                        from = values[:from].map { |v| quote_value(v) }.join(',')
-                        to = values[:to].map { |v| quote_value(v) }.join(',')
-                        "FOR VALUES FROM (#{from}) TO (#{to})"
-                      elsif values.key?(:modulus)
-                        "FOR VALUES WITH (modulus #{values[:modulus]}, remainder #{values[:remainder]})"
-                      else
-                        raise NotImplementedError
-                      end
-          create_table(name, id: false, options: "PARTITION OF #{table_name} #{condition}")
-        end
-
-        def remove_partition(_table_name, name:)
-          drop_table(name)
-        end
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    class PostgreSQLAdapter
-      prepend Ridgepole::Ext::PostgreSQLAdapter::Partitioning
-    end
-  end
-end