activerecord-turntable 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65f26f1f0d729de81434f01e9bcaaff91ed996e7
-  data.tar.gz: 789697728baf93d532fdd47b711473debe693437
+  metadata.gz: 66d31edc8c786999ddb71e35bf5f64e3dd97978a
+  data.tar.gz: 5cad32e83086caff4e7fdb1ad8c89e0393286c3e
 SHA512:
-  metadata.gz: 4ba8a9f58defbc75afc069b299d5bd27e3a7688bf176f86b7f5670a56bd129bae4d7e0988ef04d78edea863105be3445e5b07f68f306ee24e427b90c03dc842d
-  data.tar.gz: '08c739c86e694240129f47c0f7dcd039107f2ca8630356796695c4e7faa13a8784da4d61b54be5804def5f6b7e041f55c02218ee4e64bca4260d8a3ac4338e08'
+  metadata.gz: 5ec384d210033d0f2831b9db8381d422a913d8d2d736ecb1422b8870ee12624ff1f0eaadf46b13c3191e2c0f5d28bf6b8fef9ea9c83deaa54866e680ccd8d441
+  data.tar.gz: 67c6d75b06df8ea9b3c5014d43454f3ec4ef7411123ce76b93fff053e37a2caf60ded5eea3f9eff31bc3d2e5f503514226ef82cc1180e0a01e812df05f3fe075

data/.travis.yml

@@ -15,6 +15,8 @@ gemfile:
   - gemfiles/rails5_0_1.gemfile
   - gemfiles/rails5_0_2.gemfile
   - gemfiles/rails5_0_3.gemfile
+  - gemfiles/rails5_1_0.gemfile
+  - gemfiles/rails5_1_1.gemfile
   - gemfiles/rails_edge.gemfile
 
 env:
@@ -40,7 +42,7 @@ matrix:
     - rvm: 2.4.1
       gemfile: gemfiles/rails_edge.gemfile
     - rvm: 2.3.4
-      gemfile: gemfiles/rails5_0_3.gemfile
+      gemfile: gemfiles/rails5_1_1.gemfile
   allow_failures:
     - rvm: ruby-head
     - gemfile: gemfiles/rails_edge.gemfile

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## activerecord-turntable 3.1.0 ##
+
+### Major Changes
+
+* Support activerecord v5.1.x
+
+### Bugfix
+
+* Fix schema dumper to dump sequence table options correctly (activerecord >= 5.0.1)
+
 ## activerecord-turntable 3.0.1 ##
 
 ### Minor Changes

data/Gemfile

@@ -2,5 +2,5 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "activerecord", "~> 5.0.1"
-gem "activesupport", "~> 5.0.1"
+gem "activerecord", "~> 5.1.1"
+gem "activesupport", "~> 5.1.1"

data/Rakefile

@@ -48,7 +48,7 @@ namespace :turntable do
       configurations.each do |configuration|
         ActiveRecord::Base.establish_connection configuration
 
-        ActiveRecord::Base.connection.create_table :users do |t|
+        ActiveRecord::Base.connection.create_table :users, comment: "comment" do |t|
           t.string :nickname
           t.string :thumbnail_url
           t.binary :blob
@@ -56,7 +56,7 @@ namespace :turntable do
           t.datetime :deleted_at
           t.timestamps
         end
-        ActiveRecord::Base.connection.create_sequence_for :users
+        ActiveRecord::Base.connection.create_sequence_for :users, comment: "comment"
 
         ActiveRecord::Base.connection.create_table :user_statuses do |t|
           t.belongs_to :user, :null => false
@@ -129,7 +129,8 @@ namespace :turntable do
   namespace :activerecord do
     task(:env) do
       ENV["ARCONFIG"] ||= File.expand_path("spec/config/activerecord_config.yml", __dir__)
-      ENV["ARVERSION"] ||= if ActiveRecord.gem_version.prerelease?
+      ENV["ARVERSION"] ||= if ActiveRecord.gem_version.prerelease? &&
+                              !ActiveRecord.gem_version.segments.include?("rc")
                              "origin/master"
                            else
                              "v#{ActiveRecord.gem_version}"
@@ -143,6 +144,7 @@ namespace :turntable do
         Dir.chdir("tmp/rails") do
           system(*%W|git checkout #{ENV['ARVERSION']}|)
         end
+        FileUtils.rm_r("test") if File.directory?("test")
         FileUtils.cp_r("tmp/rails/activerecord/test", ".")
         FileUtils.cp_r("tmp/rails/activerecord/Rakefile", "activerecord.rake")
         File.open("test/cases/helper.rb", "a") do |f|

data/gemfiles/rails5_1_0.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "activerecord", "5.1.0"
+gem "activesupport", "5.1.0"
+gem "actionview", "5.1.0"
+
+gemspec :path => '../'

data/gemfiles/rails5_1_1.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "activerecord", "5.1.1"
+gem "activesupport", "5.1.1"
+gem "actionview", "5.1.1"
+
+gemspec :path => '../'

data/lib/active_record/turntable.rb

@@ -24,6 +24,7 @@ module ActiveRecord::Turntable
     autoload :ClusterHelperMethods
     autoload :Config
     autoload :ConnectionProxy
+    autoload :Compatibility
     autoload :MasterShard
     autoload :Migration
     autoload :Mixer

data/lib/active_record/turntable/active_record_ext/abstract_adapter.rb

@@ -1,6 +1,13 @@
 module ActiveRecord::Turntable
   module ActiveRecordExt
     module AbstractAdapter
+      extend Compatibility
+
+      def self.prepended(klass)
+        klass.prepend(self.compatible_module)
+        klass.class_eval { protected :log }
+      end
+
       def translate_exception_class(e, sql)
         begin
           message = "#{e.class.name}: #{e.message}: #{sql} : #{turntable_shard_name}"
@@ -12,11 +19,32 @@ module ActiveRecord::Turntable
         exception.set_backtrace e.backtrace
         exception
       end
+      protected :translate_exception_class
 
       # @note override for append current shard name
       # rubocop:disable Style/HashSyntax, Style/MultilineMethodCallBraceLayout
-      if ActiveRecord::Turntable::Util.ar_version_equals_or_later?("5.0.3")
+      module V5_1
         def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+          @instrumenter.instrument(
+            "sql.active_record",
+            sql:                  sql,
+            name:                 name,
+            binds:                binds,
+            type_casted_binds:    type_casted_binds,
+            statement_name:       statement_name,
+            connection_id:        object_id,
+            turntable_shard_name: turntable_shard_name) do
+              @lock.synchronize do
+                yield
+              end
+            end
+        rescue => e
+          raise translate_exception_class(e, sql)
+        end
+      end
+
+      module V5_0_3
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
           @instrumenter.instrument(
             "sql.active_record",
             sql:                  sql,
@@ -29,7 +57,9 @@ module ActiveRecord::Turntable
         rescue => e
           raise translate_exception_class(e, sql)
         end
-      else
+      end
+
+      module V5_0
         def log(sql, name = "SQL", binds = [], statement_name = nil)
           @instrumenter.instrument(
             "sql.active_record",
@@ -45,7 +75,6 @@ module ActiveRecord::Turntable
       end
       # rubocop:enable Style/HashSyntax, Style/MultilineMethodCallBraceLayout
 
-      protected :translate_exception_class, :log
 
       def turntable_shard_name=(name)
         @turntable_shard_name = name.to_s

data/lib/active_record/turntable/active_record_ext/connection_handler_extension.rb

@@ -11,7 +11,9 @@ module ActiveRecord::Turntable
               # A connection was established in an ancestor process that must have
               # subsequently forked. We can't reuse the connection, but we can copy
               # the specification and establish a new connection with it.
-              establish_connection(ancestor_pool.spec).tap do |pool|
+              spec = ancestor_pool.spec
+              spec = spec.to_hash if spec.respond_to?(:to_hash)
+              establish_connection(spec).tap do |pool|
                 pool.schema_cache = ancestor_pool.schema_cache if ancestor_pool.schema_cache
               end
             else

data/lib/active_record/turntable/active_record_ext/fixtures.rb

@@ -2,6 +2,7 @@
 # force TestFixtures to begin transaction with all shards.
 #
 require "active_record/fixtures"
+require "active_record/turntable/util"
 
 module ActiveRecord
   class FixtureSet
@@ -79,6 +80,7 @@ module ActiveRecord
       @fixture_cache = {}
       @fixture_connections = []
       @@already_loaded_fixtures ||= {}
+      @connection_subscriber = nil
 
       # Load fixtures once and begin transaction.
       if run_in_transaction?
@@ -88,11 +90,38 @@ module ActiveRecord
           @loaded_fixtures = load_fixtures(config)
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
+
+        # Begin transactions for connections already established
         ActiveRecord::Base.force_connect_all_shards!
         @fixture_connections = enlist_fixture_connections
         @fixture_connections.each do |connection|
           connection.begin_transaction joinable: false
+          if ActiveRecord::Turntable::Util.ar51_or_later?
+            connection.pool.lock_thread = true
+          end
         end
+
+        if ActiveRecord::Turntable::Util.ar51_or_later?
+          # When connections are established in the future, begin a transaction too
+          @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
+            spec_name = payload[:spec_name] if payload.key?(:spec_name)
+
+            if spec_name
+              begin
+                connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name)
+              rescue ConnectionNotEstablished
+                connection = nil
+              end
+
+              if connection && !@fixture_connections.include?(connection)
+                connection.begin_transaction joinable: false
+                connection.pool.lock_thread = true
+                @fixture_connections << connection
+              end
+            end
+          end
+        end
+
       # Load fixtures for every test.
       else
         ActiveRecord::FixtureSet.reset_cache

data/lib/active_record/turntable/active_record_ext/locking_optimistic.rb

@@ -1,53 +1,105 @@
 module ActiveRecord::Turntable
   module ActiveRecordExt
     module LockingOptimistic
-      ::ActiveRecord::Locking::Optimistic.class_eval <<-EOD
-        private
-        # @note Override to add sharding condition on optimistic locking
-        def _update_record(attribute_names = self.attribute_names) #:nodoc:
-          return super unless locking_enabled?
-          return 0 if attribute_names.empty?
-
-          klass = self.class
-          lock_col = self.class.locking_column
-          previous_lock_value = send(lock_col).to_i
-          increment_lock
-
-          attribute_names += [lock_col]
-          attribute_names.uniq!
-
-          begin
-            relation = self.class.unscoped
-
-            condition_scope = relation.where(
-              self.class.primary_key => id,
-              lock_col => previous_lock_value,
-            )
-            if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-              condition_scope = condition_scope.where(
-                klass.turntable_shard_key => self.send(klass.turntable_shard_key)
+      if Util.ar51_or_later?
+        ::ActiveRecord::Locking::Optimistic.class_eval <<-EOD
+          private
+          # @note Override to add sharding condition on optimistic locking
+          def _update_record(attribute_names = self.attribute_names)
+            return super unless locking_enabled?
+            return 0 if attribute_names.empty?
+
+            begin
+              klass = self.class
+
+              lock_col = self.class.locking_column
+
+              previous_lock_value = read_attribute_before_type_cast(lock_col)
+
+              increment_lock
+
+              attribute_names.push(lock_col)
+
+              relation = self.class.unscoped
+
+              condition_scope = relation.where(
+                self.class.primary_key => id,
+                lock_col => previous_lock_value
               )
-            end
+              if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
+                condition_scope = condition_scope.where(
+                  klass.turntable_shard_key => self.send(klass.turntable_shard_key)
+                )
+              end
+
+              affected_rows = condition_scope.update_all(
+                attributes_for_update(attribute_names).map do |name|
+                  [name, _read_attribute(name)]
+                end.to_h
+              )
+
+              unless affected_rows == 1
+                raise ActiveRecord::StaleObjectError.new(self, "update")
+              end
 
-            affected_rows = condition_scope.update_all(
-              attributes_for_update(attribute_names).map do |name|
-                [name, _read_attribute(name)]
-              end.to_h
-            )
+              affected_rows
 
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError.new(self, "update")
+            # If something went wrong, revert the locking_column value.
+            rescue Exception
+              send(lock_col + "=", previous_lock_value.to_i)
+              raise
             end
+          end
+        EOD
+      else
+        ::ActiveRecord::Locking::Optimistic.class_eval <<-EOD
+          private
+          # @note Override to add sharding condition on optimistic locking
+          def _update_record(attribute_names = self.attribute_names) #:nodoc:
+            return super unless locking_enabled?
+            return 0 if attribute_names.empty?
+
+            klass = self.class
+            lock_col = self.class.locking_column
+            previous_lock_value = send(lock_col).to_i
+            increment_lock
+
+            attribute_names += [lock_col]
+            attribute_names.uniq!
+
+            begin
+              relation = self.class.unscoped
+
+              condition_scope = relation.where(
+                self.class.primary_key => id,
+                lock_col => previous_lock_value,
+              )
+              if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
+                condition_scope = condition_scope.where(
+                  klass.turntable_shard_key => self.send(klass.turntable_shard_key)
+                )
+              end
+
+              affected_rows = condition_scope.update_all(
+                attributes_for_update(attribute_names).map do |name|
+                  [name, _read_attribute(name)]
+                end.to_h
+              )
 
-            affected_rows
+              unless affected_rows == 1
+                raise ActiveRecord::StaleObjectError.new(self, "update")
+              end
 
-            # If something went wrong, revert the version.
-          rescue Exception
-            send(lock_col + '=', previous_lock_value)
-            raise
+              affected_rows
+
+              # If something went wrong, revert the version.
+            rescue Exception
+              send(lock_col + '=', previous_lock_value)
+              raise
+            end
           end
-        end
-      EOD
+        EOD
+      end
     end
   end
 end

data/lib/active_record/turntable/active_record_ext/persistence.rb

@@ -29,7 +29,12 @@ module ActiveRecord::Turntable
         # @note Override to add sharding scope on `touch`
         # rubocop:disable Style/UnlessElse
         def touch(*names, time: nil)
-          raise ActiveRecord::ActiveRecordError, "cannot touch on a new record object" unless persisted?
+          unless persisted?
+            raise ActiveRecord::ActiveRecordError, <<-MSG.squish
+              cannot touch on a new or destroyed record object. Consider using
+              persisted?, new_record?, or destroyed? before touching
+            MSG
+          end
 
           time ||= current_time_from_proper_timezone
           attributes = timestamp_attributes_for_update_in_model
@@ -43,7 +48,7 @@ module ActiveRecord::Turntable
               changes[column] = write_attribute(column, time)
             end
 
-            clear_attribute_changes(changes.keys)
+            clear_attribute_changes(changes.keys) unless Util.ar51_or_later?
             primary_key = self.class.primary_key
             scope = if turntable_enabled? && primary_key != self.class.turntable_shard_key.to_s
                       self.class.unscoped.where(self.class.turntable_shard_key => _read_attribute(turntable_shard_key))
@@ -58,12 +63,14 @@ module ActiveRecord::Turntable
               changes[locking_column] = increment_lock
             end
 
+            clear_attribute_changes(changes.keys) if Util.ar51_or_later?
             result = scope.update_all(changes) == 1
 
             if !result && locking_enabled?
               raise ActiveRecord::StaleObjectError.new(self, "touch")
             end
 
+            @_trigger_update_callback = result
             result
           else
             true
@@ -113,13 +120,20 @@ module ActiveRecord::Turntable
             klass = self.class
             attributes_values = arel_attributes_with_values_for_update(attribute_names)
             if attributes_values.empty?
-              0
+              rows_affected = 0
+              @_trigger_update_callback = true
             else
               scope = if klass.turntable_enabled? && (klass.primary_key != klass.turntable_shard_key.to_s)
                         klass.unscoped.where(klass.turntable_shard_key => self.send(turntable_shard_key))
                       end
-              klass.unscoped._update_record attributes_values, id, id_was, scope
+              previous_id = Util.ar51_or_later? ? id_in_database : id_was
+              rows_affected = klass.unscoped._update_record attributes_values, id, previous_id, scope
+              @_trigger_update_callback = rows_affected > 0
             end
+
+            yield(self) if block_given?
+
+            rows_affected
           end
       end
     end

data/lib/active_record/turntable/active_record_ext/query_cache.rb

@@ -3,40 +3,36 @@ module ActiveRecord::Turntable
     module QueryCache
       def self.prepended(klass)
         class << klass
-          if Util.ar_version_equals_or_later?("5.0.1")
-            prepend(ClassMethods::AR5_0_1)
-          else
-            prepend(ClassMethods::AR5_0)
-          end
+          prepend ClassMethods.compatible_module
         end
       end
 
       module ClassMethods
-        module AR5_0
+        extend Compatibility
+
+        module V5_1
           def run
             result = super
 
             pools = ActiveRecord::Base.turntable_connections.values
-            pools.each do |k|
-              k.connection.enable_query_cache!
+            pools.each do |pool|
+              pool.enable_query_cache!
             end
 
-            result
+            [*result, pools]
           end
 
           def complete(state)
-            enabled, _connection_id = state
-            super
+            caching_pool, caching_was_enabled, turntable_pools = state
+            super([caching_pool, caching_was_enabled])
 
-            klasses = ActiveRecord::Base.turntable_connections.values
-            klasses.each do |k|
-              k.connection.clear_query_cache
-              k.connection.disable_query_cache! unless enabled
+            turntable_pools.each do |pool|
+              pool.disable_query_cache! unless caching_was_enabled
             end
           end
         end
 
-        module AR5_0_1
+        module V5_0_1
           def run
             result = super
 
@@ -57,6 +53,30 @@ module ActiveRecord::Turntable
             end
           end
         end
+
+        module V5_0
+          def run
+            result = super
+
+            pools = ActiveRecord::Base.turntable_connections.values
+            pools.each do |k|
+              k.connection.enable_query_cache!
+            end
+
+            result
+          end
+
+          def complete(state)
+            enabled, _connection_id = state
+            super
+
+            klasses = ActiveRecord::Base.turntable_connections.values
+            klasses.each do |k|
+              k.connection.clear_query_cache
+              k.connection.disable_query_cache! unless enabled
+            end
+          end
+        end
       end
 
       def self.install_turntable_executor_hooks(executor = ActiveSupport::Executor)

data/lib/active_record/turntable/active_record_ext/schema_dumper.rb

@@ -20,11 +20,14 @@ module ActiveRecord::Turntable
 
             table_options = @connection.table_options(table)
             if table_options.present?
-              options = respond_to?(:format_options) ? format_options(table_options) : table_options.inspect
-              tbl.print ", options: #{options}"
+              if respond_to?(:format_options, true)
+                tbl.print ", #{format_options(table_options)}"
+              else
+                tbl.print ", options: #{table_options.inspect}"
+              end
             end
 
-            if comment = @connection.table_comment(table).presence
+            if Util.ar_version_earlier_than?("5.0.1") && comment = @connection.table_comment(table).presence
               tbl.print ", comment: #{comment.inspect}"
             end
             tbl.puts

data/lib/active_record/turntable/active_record_ext/transactions.rb

@@ -3,28 +3,25 @@ module ActiveRecord::Turntable
     module Transactions
       # @note Override to start transaction on current shard
       def with_transaction_returning_status
-        if self.class.turntable_enabled?
-          status = nil
-          if self.new_record? && self.turntable_shard_key.to_s == self.class.primary_key &&
-             self.id.nil? && self.class.connection.prefetch_primary_key?(self.class.table_name)
-            self.id = self.class.connection.next_sequence_value(self.class.sequence_name)
-          end
-          self.class.connection.shards_transaction([self.turntable_shard]) do
-            add_to_transaction
-            begin
-              status = yield
-            rescue ActiveRecord::Rollback
-              clear_transaction_record_state
-              status = nil
-            end
+        return super unless self.class.turntable_enabled?
 
-            raise ActiveRecord::Rollback unless status
-          end
-          status
-        else
-          super
+        status = nil
+        if self.new_record? && self.turntable_shard_key.to_s == self.class.primary_key &&
+            self.id.nil? && self.class.connection.prefetch_primary_key?(self.class.table_name)
+          self.id = self.class.connection.next_sequence_value(self.class.sequence_name)
         end
+        self.class.connection.shards_transaction([self.turntable_shard]) do
+          add_to_transaction
+          begin
+            status = yield
+          rescue ActiveRecord::Rollback
+            clear_transaction_record_state
+            status = nil
+          end
 
+          raise ActiveRecord::Rollback unless status
+        end
+        status
       ensure
         if @transaction_state && @transaction_state.committed?
           clear_transaction_record_state
@@ -32,17 +29,15 @@ module ActiveRecord::Turntable
       end
 
       def add_to_transaction
-        if self.class.turntable_enabled?
-          if has_transactional_callbacks?
-            self.turntable_shard.connection.add_transaction_record(self)
-          else
-            sync_with_transaction_state
-            set_transaction_state(self.turntable_shard.connection.transaction_state)
-          end
-          remember_transaction_record_state
+        return super unless self.class.turntable_enabled?
+
+        if has_transactional_callbacks?
+          self.turntable_shard.connection.add_transaction_record(self)
         else
-          super
+          sync_with_transaction_state
+          set_transaction_state(self.turntable_shard.connection.transaction_state)
         end
+        remember_transaction_record_state
       end
     end
   end

data/lib/active_record/turntable/compatibility.rb

@@ -0,0 +1,44 @@
+module ActiveRecord::Turntable
+  module Compatibility
+    def self.extended(base)
+      base.instance_variable_set(:@_compatible_versions, [])
+    end
+
+    def [](version = ActiveRecord.gem_version.release)
+      unless version.is_a?(Gem::Version)
+        version = Gem::Version.new(version)
+      end
+      find_compatible_module(version)
+    end
+    alias_method :compatible_module, :[]
+
+    def find_compatible_module(version)
+      module_version = find_compatible_version(version)
+      const_get("V#{module_version.to_s.tr(".", "_")}")
+    end
+
+    def find_compatible_version(version)
+      target_version = nil
+
+      compatible_versions.each do |compatible_version|
+        break if version < compatible_version
+        target_version = compatible_version
+      end
+
+      target_version
+    end
+
+    def compatible_versions
+      if @_compatible_versions.empty?
+        @_compatible_versions = constants.map do |const|
+          /^V(?<major>\d+)(_(?<minor>\d+)(_(?<teeny>\d))?)?/ =~ const
+          nil unless major
+          Gem::Version.new([major, minor, teeny].compact.join("."))
+        end
+        @_compatible_versions.compact!
+        @_compatible_versions.sort!
+      end
+      @_compatible_versions
+    end
+  end
+end

data/lib/active_record/turntable/util.rb

@@ -9,11 +9,16 @@ module ActiveRecord::Turntable
     end
 
     def ar_version
-      ActiveRecord.gem_version
+      ActiveRecord.gem_version.release
+    end
+
+    def ar51_or_later?
+      ar_version_equals_or_later?("5.1")
     end
 
     module_function :ar_version_equals_or_later?,
                     :ar_version_earlier_than?,
-                    :ar_version
+                    :ar_version,
+                    :ar51_or_later?
   end
 end

data/lib/active_record/turntable/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Turntable
-    VERSION = "3.0.1".freeze
+    VERSION = "3.1.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-turntable
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - gussan
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-13 00:00:00.000000000 Z
+date: 2017-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -513,6 +513,8 @@ files:
 - gemfiles/rails5_0_1.gemfile
 - gemfiles/rails5_0_2.gemfile
 - gemfiles/rails5_0_3.gemfile
+- gemfiles/rails5_1_0.gemfile
+- gemfiles/rails5_1_1.gemfile
 - gemfiles/rails_edge.gemfile
 - lib/active_record/turntable.rb
 - lib/active_record/turntable/active_record_ext.rb
@@ -544,6 +546,7 @@ files:
 - lib/active_record/turntable/base.rb
 - lib/active_record/turntable/cluster.rb
 - lib/active_record/turntable/cluster_helper_methods.rb
+- lib/active_record/turntable/compatibility.rb
 - lib/active_record/turntable/config.rb
 - lib/active_record/turntable/connection_proxy.rb
 - lib/active_record/turntable/connection_proxy/mixable.rb