ridgepole 1.0.7 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7886d7c158b4776c9db77e73c72ab5d882241950ed6a9f2c945a99220b7bcc4a
-  data.tar.gz: 6429c8b8ed0c17dd1361c0e01592180c521002fa64fead1e625e9ec7ab2436a9
+  metadata.gz: '068fca35b633df2e4bc3b2d8ad5d2553496396a78c16ca371f18efc4dbad6adf'
+  data.tar.gz: c908229a06ddcbbf28e14b28af7f52f63c933d271db2e24231f6ed588fe5a1a0
 SHA512:
-  metadata.gz: a7a06ba181dbdad2e0dd6f054366d745a3dbd119715bdb83b9a5e440c8a2258014859b2f9a8916b75fd5fb0ed9c27c4a32efe7d51761d7dd62a5e313cbad6fae
-  data.tar.gz: '0277821bd5e0fc9c47ec038bf938a1b1a8c18c8395af8fd5ccfdf14ed9a8b80b03c5b6550f7b11d4da7220023be6e14782261a0a85f5b70ad7d136561bce4724'
+  metadata.gz: 6456e47a675dbdeb21ce56c9ed6091e823031ca082b191b7fb0438880d54ee6aea51988d4d9c5e07ded0e684a683d22f0d613cd3697c7c6d12ef6948b41e972e
+  data.tar.gz: 4b9f3b573975e0be50dec442e7db23688374754306082275bcc711e20e5813f2c4ca1975993797e02fd5b963cf396b7f5bbd2cd869f02aee468c8d07ce98e3c1

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/Appraisals

@@ -1,22 +1,13 @@
 # frozen_string_literal: true
 
-appraise 'activerecord-5.1' do
-  gem 'activerecord', '~> 5.1.0'
-end
-
-appraise 'activerecord-5.2' do
-  gem 'activerecord', '~> 5.2.0'
-  gem 'mysql2', '~> 0.4.4'
-end
-
 appraise 'activerecord-6.0' do
-  gem 'activerecord', '~> 6.0.0'
+  gem 'activerecord', '~> 6.0.6'
 end
 
 appraise 'activerecord-6.1' do
-  gem 'activerecord', '~> 6.1.0'
+  gem 'activerecord', '~> 6.1.7'
 end
 
 appraise 'activerecord-7.0' do
-  gem 'activerecord', '~> 7.0.0'
+  gem 'activerecord', '~> 7.0.4'
 end

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.2
+
+### 1.2.0 (2022/09/24)
+
+* Updated supported column types [pull#399](https://github.com/ridgepole/ridgepole/pull/399) [pull#400](https://github.com/ridgepole/ridgepole/pull/400)
+* Support check constraint [pull#393](https://github.com/ridgepole/ridgepole/pull/393) [pull#397](https://github.com/ridgepole/ridgepole/pull/397)
+* Drop suport Rails 5.x [pull#395](https://github.com/ridgepole/ridgepole/pull/395 )
+
+## 1.1
+
+### 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)

data/README.md

@@ -6,11 +6,13 @@ It defines DB schema using [Rails DSL](http://guides.rubyonrails.org/migrations.
 (like Chef/Puppet)
 
 [![Gem Version](https://badge.fury.io/rb/ridgepole.svg)](http://badge.fury.io/rb/ridgepole)
-[![Build Status](https://github.com/ridgepole/ridgepole/workflows/test/badge.svg?branch=1.0)](https://github.com/ridgepole/ridgepole/actions)
-[![Coverage Status](https://coveralls.io/repos/github/ridgepole/ridgepole/badge.svg?branch=1.0)](https://coveralls.io/github/ridgepole/ridgepole?branch=1.0)
+[![Build Status](https://github.com/ridgepole/ridgepole/workflows/test/badge.svg?branch=1.2)](https://github.com/ridgepole/ridgepole/actions)
+[![Coverage Status](https://coveralls.io/repos/github/ridgepole/ridgepole/badge.svg?branch=1.2)](https://coveralls.io/github/ridgepole/ridgepole?branch=1.2)
 
 **Notice**
 
+* Drop support ActiveRecord 5.x in ridgepole v1.2.0.
+* 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 +218,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 +320,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/docker-compose.yml

@@ -1,19 +1,19 @@
 version: "3.8"
 services:
   mysql:
-    image: "mysql:5.6"
+    image: "mysql:5.6.51"
     ports:
       - "13316:3306"
     environment:
       MYSQL_ROOT_PASSWORD: password
   mysql57:
-    image: "mysql:5.7"
+    image: "mysql:5.7.39"
     ports:
       - "13317:3306"
     environment:
       MYSQL_ROOT_PASSWORD: password
   mysql80:
-    image: "mysql:8.0"
+    image: "mysql:8.0.30"
     ports:
       - "13318:3306"
     environment:

data/gemfiles/activerecord_6.0.gemfile

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 6.0.0"
+gem "activerecord", "~> 6.0.6"
 
 gemspec path: "../"

data/gemfiles/activerecord_6.1.gemfile

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 6.1.0"
+gem "activerecord", "~> 6.1.7"
 
 gemspec path: "../"

data/gemfiles/activerecord_7.0.gemfile

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 7.0.0"
+gem "activerecord", "~> 7.0.4"
 
 gemspec path: "../"

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

@@ -245,6 +245,12 @@ create_table(#{table_name.inspect}, #{inspect_options_include_default_proc(optio
         end
       end
 
+      unless (check_constraints = attrs[:check_constraints] || {}).empty?
+        check_constraints.each do |_, check_constraint_attrs|
+          append_add_check_constraint(table_name, check_constraint_attrs, buf, true)
+        end
+      end
+
       buf.puts(<<-RUBY)
 end
       RUBY
@@ -310,29 +316,12 @@ 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] || {}
+      check_constraints = attrs[:check_constraints] || {}
       table_options = attrs[:table_options]
       table_charset = attrs[:table_charset]
       table_collation = attrs[:table_collation]
@@ -348,6 +337,7 @@ 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?
 
       if table_options || table_charset || table_collation
         append_change_table_raw_options(table_name, table_options, table_charset, table_collation,
@@ -356,10 +346,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
@@ -533,6 +519,40 @@ remove_foreign_key(#{table_name.inspect}, #{target})
     RUBY
     end
 
+    def append_change_check_constraints(table_name, delta, buf)
+      (delta[:delete] || {}).each do |_, attrs|
+        append_remove_check_constraint(table_name, attrs, buf)
+      end
+
+      (delta[:add] || {}).each 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 delta_execute
       @delta[:execute] || []
     end

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)
@@ -104,6 +101,7 @@ module Ridgepole
       scan_definition_change(from[:definition], to[:definition], from[:indices], table_name, from[:options], table_delta)
       scan_indices_change(from[:indices], to[:indices], to[:definition], table_delta, from[:options], to[:options])
       scan_foreign_keys_change(from[:foreign_keys], to[:foreign_keys], table_delta, @options)
+      scan_check_constraints_change(from[:check_constraints], to[:check_constraints], table_delta)
 
       unless table_delta.empty?
         delta[:change] ||= {}
@@ -475,6 +473,38 @@ module Ridgepole
       table_delta[:foreign_keys] = foreign_keys_delta unless foreign_keys_delta.empty?
     end
 
+    def scan_check_constraints_change(from, to, table_delta)
+      from = (from || {}).dup
+      to = (to || {}).dup
+      check_constraints_delta = {}
+
+      to.each do |name, to_attrs|
+        from_attrs = from.delete(name)
+
+        if from_attrs
+          if from_attrs != to_attrs
+            check_constraints_delta[:add] ||= {}
+            check_constraints_delta[:add][name] = to_attrs
+
+            check_constraints_delta[:delete] ||= {}
+            check_constraints_delta[:delete][name] = from_attrs
+          end
+        else
+          check_constraints_delta[:add] ||= {}
+          check_constraints_delta[:add][name] = to_attrs
+        end
+      end
+
+      unless @options[:merge]
+        from.each do |name, from_attrs|
+          check_constraints_delta[:delete] ||= {}
+          check_constraints_delta[:delete][name] = from_attrs
+        end
+      end
+
+      table_delta[:check_constraints] = check_constraints_delta unless check_constraints_delta.empty?
+    end
+
     # XXX: MySQL only?
     # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb#L760
     # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb#L102
@@ -620,56 +650,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,22 +91,18 @@ 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,
+      def add_check_constraint(table_name, expression, options = {})
+        table_name = table_name.to_s
+        expression = expression.to_s
+        options[:name] = options[:name].to_s if options[:name]
+
+        idx = options[:name] || expression
+
+        @__definition[table_name] ||= {}
+        @__definition[table_name][:check_constraints] ||= {}
+        @__definition[table_name][:check_constraints][idx] = {
+          expression: expression,
+          options: options,
         }
       end
 

data/lib/ridgepole/dsl_parser/table_definition.rb

@@ -26,32 +26,41 @@ module Ridgepole
       DEFAULT_PRIMARY_KEY_TYPE = :bigint
 
       TYPES = {
-        # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L274
-        string: {},
-        text: {},
-        integer: {},
+        # https://github.com/rails/rails/blob/main/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L300-L301
         bigint: {},
-        float: {},
-        decimal: {},
-        datetime: {},
-        timestamp: {},
-        time: {},
-        date: {},
         binary: {},
         boolean: {},
+        date: {},
+        datetime: {},
+        decimal: {},
+        float: {},
+        integer: {},
+        json: {},
+        string: {},
+        text: {},
+        time: {},
+        timestamp: {},
+        virtual: {},
 
-        # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L79
+        # https://github.com/rails/rails/blob/v6.0.6/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L101
         serial: { null: false },
         bigserial: { null: false },
+        # string: {},
+        # text: {},
+        # integer: {},
+        # float: {},
+        # decimal: {},
+        # datetime: {},
+        # time: {},
+        # date: {},
         daterange: {},
         numrange: {},
         tsrange: {},
         tstzrange: {},
         int4range: {},
         int8range: {},
-        # binary: {}, # dup key
-        # boolean: {}, # dup key
-        # bigint: {}, # dup key
+        # binary: {},
+        # boolean: {},
         xml: {},
         tsvector: {},
         hstore: {},
@@ -59,20 +68,25 @@ module Ridgepole
         cidr: {},
         macaddr: {},
         uuid: {},
-        json: {},
+        # json: {},
         jsonb: {},
         ltree: {},
         citext: {},
         point: {},
+        line: {},
+        lseg: {},
+        box: {},
+        path: {},
+        polygon: {},
+        circle: {},
         bit: {},
         bit_varying: {},
         money: {},
+        interval: {},
+        oid: {},
 
-        # https://github.com/rails/rails/blob/v5.1.1/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L184
-        virtual: {},
-
-        # https://github.com/rails/rails/blob/v5.0.4/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb#L53
-        # json: {}, # dup key
+        # https://github.com/ridgepole/ridgepole/issues/394
+        timestamptz: {},
       }.freeze
 
       TYPES.each do |column_type, default_options|
@@ -159,6 +173,10 @@ module Ridgepole
         end
       end
       alias belongs_to references
+
+      def check_constraint(expression, options = {})
+        @base.add_check_constraint(@table_name, expression, options)
+      end
     end
   end
 end

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.2.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.2.0
 platform: ruby
 authors:
 - Genki Sugawara
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-08 00:00:00.000000000 Z
+date: 2022-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -288,8 +288,6 @@ files:
 - Rakefile
 - bin/ridgepole
 - docker-compose.yml
-- gemfiles/activerecord_5.1.gemfile
-- gemfiles/activerecord_5.2.gemfile
 - gemfiles/activerecord_6.0.gemfile
 - gemfiles/activerecord_6.1.gemfile
 - gemfiles/activerecord_7.0.gemfile
@@ -306,13 +304,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/gemfiles/activerecord_5.1.gemfile

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

data/gemfiles/activerecord_5.2.gemfile

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

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