activerecord-turntable 2.5.0 → 3.0.0.alpha1

data/lib/active_record/turntable/mixer/fader/calculate_shards_sum_result.rb

@@ -13,13 +13,13 @@ module ActiveRecord::Turntable
 
         private
 
-        def merge_results(results)
-          ActiveRecord::Result.new(
-            results.first.columns,
-            results[0].rows.zip(*results[1..-1].map{|r| r.rows}).map {|r| [r.map {|v| v.first}.inject(&:+)]},
-            results.first.column_types
-          )
-        end
+          def merge_results(results)
+            ActiveRecord::Result.new(
+              results.first.columns,
+              results[0].rows.zip(*results[1..-1].map(&:rows)).map { |r| [r.map(&:first).inject(&:+)] },
+              results.first.column_types
+            )
+          end
       end
     end
   end

data/lib/active_record/turntable/mixer/fader/select_shards_merge_result.rb

@@ -13,20 +13,20 @@ module ActiveRecord::Turntable
 
         private
 
-        def merge_results(results)
-          if results.any? {|r| r.is_a?(ActiveRecord::Result) }
-            first_result = results.find {|r| r.present? }
-            return results.first unless first_result
+          def merge_results(results)
+            if results.any? { |r| r.is_a?(ActiveRecord::Result) }
+              first_result = results.find(&:present?)
+              return results.first unless first_result
 
-            ActiveRecord::Result.new(
-              first_result.columns,
-              results.map {|r| r.rows}.flatten(1),
-              first_result.column_types
-            )
-          else
-            results.compact.inject(&:+)
+              ActiveRecord::Result.new(
+                first_result.columns,
+                results.flat_map(&:rows),
+                first_result.column_types
+              )
+            else
+              results.compact.inject(&:+)
+            end
           end
-        end
       end
     end
   end

data/lib/active_record/turntable/mixer.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/object/try'
-require 'active_record/turntable/sql_tree_patch'
+require "active_support/core_ext/object/try"
+require "active_record/turntable/sql_tree_patch"
 
 module ActiveRecord::Turntable
   class Mixer
@@ -9,7 +9,7 @@ module ActiveRecord::Turntable
       autoload :Fader
     end
 
-    delegate :logger, :to => ActiveRecord::Base
+    delegate :logger, to: ActiveRecord::Base
 
     NOT_USED_FOR_SHARDING_OPERATORS_REGEXP = /\A(NOT IN|IS|IS NOT|BETWEEN|LIKE|\!\=|<<|>>|<>|>\=|<=|[\*\+\-\/\%\|\&><])\z/
 
@@ -24,7 +24,7 @@ module ActiveRecord::Turntable
                                   { @proxy.fixed_shard => query },
                                   method, query, *args, &block)
       end
-      binds = (method == 'insert') ? args[4] : args[1]
+      binds = (method == "insert") ? args[4] : args[1]
       binded_query = bind_sql(query, binds)
 
       begin
@@ -44,8 +44,8 @@ module ActiveRecord::Turntable
       else
         # send to master shard
         Fader::SpecifiedShard.new(@proxy,
-                           { @proxy.master => query },
-                           method, query, *args, &block)
+                                  { @proxy.master => query },
+                                  method, query, *args, &block)
       end
     rescue Exception => err
       logger.warn { "[ActiveRecord::Turntable] Error on Building Fader: #{binded_query}, on_method: #{method_name}, err: #{err}" }
@@ -59,7 +59,7 @@ module ActiveRecord::Turntable
       when "OR"
         lkeys = find_shard_keys(tree.lhs, table_name, shard_key)
         rkeys = find_shard_keys(tree.rhs, table_name, shard_key)
-        if lkeys.present? and rkeys.present?
+        if lkeys.present? && rkeys.present?
           lkeys + rkeys
         else
           []
@@ -67,7 +67,7 @@ module ActiveRecord::Turntable
       when "AND"
         lkeys = find_shard_keys(tree.lhs, table_name, shard_key)
         rkeys = find_shard_keys(tree.rhs, table_name, shard_key)
-        if lkeys.present? or rkeys.present?
+        if lkeys.present? || rkeys.present?
           lkeys + rkeys
         else
           []
@@ -93,141 +93,141 @@ module ActiveRecord::Turntable
         []
       else
         raise ActiveRecord::Turntable::UnknownOperatorError,
-          "[ActiveRecord::Turntable] Found Unknown SQL Operator:'#{tree.operator if tree.respond_to?(:operaor)}', Please report this bug."
+              "[ActiveRecord::Turntable] Found Unknown SQL Operator:'#{tree.operator if tree.respond_to?(:operaor)}', Please report this bug."
       end
     end
 
     private
 
-    def divide_insert_values(tree, shard_key_name)
-      idx = tree.fields.find_index {|f| f.name == shard_key_name.to_s }
-      result = {}
-      tree.values.each do |val|
-        (result[val[idx].value] ||= []) << val
+      def divide_insert_values(tree, shard_key_name)
+        idx = tree.fields.find_index { |f| f.name == shard_key_name.to_s }
+        result = {}
+        tree.values.each do |val|
+          (result[val[idx].value] ||= []) << val
+        end
+        result
       end
-      return result
-    end
 
-    def build_shards_with_same_query(shards, query)
-      Hash[shards.map {|s| [s, query] }]
-    end
+      def build_shards_with_same_query(shards, query)
+        Hash[shards.map { |s| [s, query] }]
+      end
 
-    def bind_sql(sql, binds)
-      # TODO: substitution value should be determined by adapter
-      query = sql.is_a?(String) ? sql : @proxy.to_sql(sql, binds ? binds.dup : [])
-      query = if query.include?("\0") and binds.is_a?(Array) and binds[0].is_a?(Array) and binds[0][0].is_a?(ActiveRecord::ConnectionAdapters::Column)
-                binds = binds.dup
-                query.gsub("\0") { @proxy.master.connection.quote(*binds.shift.reverse) }
-              else
-                query
-              end
-    end
+      def bind_sql(sql, binds)
+        # TODO: substitution value should be determined by adapter
+        query = sql.is_a?(String) ? sql : @proxy.to_sql(sql, binds ? binds.dup : [])
+        query = if query.include?("\0") && binds.is_a?(Array) && binds[0].is_a?(Array) && binds[0][0].is_a?(ActiveRecord::ConnectionAdapters::Column)
+                  binds = binds.dup
+                  query.gsub("\0") { @proxy.master.connection.quote(*binds.shift.reverse) }
+                else
+                  query
+                end
+      end
 
-    def build_select_fader(tree, method, query, *args, &block)
-      shard_keys = if !tree.where and tree.from.size == 1 and SQLTree::Node::SubQuery === tree.from.first.table_reference.table
-                     find_shard_keys(tree.from.first.table_reference.table.where,
-                                     @proxy.klass.table_name,
-                                     @proxy.klass.turntable_shard_key.to_s)
-                   else
-                     find_shard_keys(tree.where,
-                                     @proxy.klass.table_name,
-                                     @proxy.klass.turntable_shard_key.to_s)
-                   end
-
-      if shard_keys.size == 1 # shard
-        return Fader::SpecifiedShard.new(@proxy,
-                                         { @proxy.cluster.shard_for(shard_keys.first) => query },
-                                         method, query, *args, &block)
-      elsif SQLTree::Node::SelectDeclaration === tree.select.first and
-              tree.select.first.to_sql == '1 AS "one"'  # for `SELECT 1 AS one` (AR::Base.exists?)
-        return Fader::SelectShardsMergeResult.new(@proxy,
-                                                  build_shards_with_same_query(@proxy.shards.values, query),
-                                                  method, query, *args, &block
-                                                  )
-      elsif tree.group_by or tree.order_by or tree.limit.try(:value).to_i > 0
-        raise CannotSpecifyShardError, "cannot specify shard for query: #{tree.to_sql}"
-      elsif shard_keys.present?
-        if SQLTree::Node::SelectDeclaration === tree.select.first and
-            SQLTree::Node::CountAggregrate === tree.select.first.expression
-          return Fader::CalculateShardsSumResult.new(@proxy,
-                                                     build_shards_with_same_query(@proxy.shards.values, query),
-                                                     method, query, *args, &block)
-        else
+      def build_select_fader(tree, method, query, *args, &block)
+        shard_keys = if !tree.where && tree.from.size == 1 && SQLTree::Node::SubQuery === tree.from.first.table_reference.table
+                       find_shard_keys(tree.from.first.table_reference.table.where,
+                                       @proxy.klass.table_name,
+                                       @proxy.klass.turntable_shard_key.to_s)
+                     else
+                       find_shard_keys(tree.where,
+                                       @proxy.klass.table_name,
+                                       @proxy.klass.turntable_shard_key.to_s)
+                     end
+
+        if shard_keys.size == 1 # shard
+          return Fader::SpecifiedShard.new(@proxy,
+                                           { @proxy.cluster.shard_for(shard_keys.first) => query },
+                                           method, query, *args, &block)
+        elsif SQLTree::Node::SelectDeclaration === tree.select.first &&
+              tree.select.first.to_sql == '1 AS "one"' # for `SELECT 1 AS one` (AR::Base.exists?)
           return Fader::SelectShardsMergeResult.new(@proxy,
-                                                    Hash[shard_keys.map {|k| [@proxy.cluster.shard_for(k), query] }],
+                                                    build_shards_with_same_query(@proxy.shards.values, query),
                                                     method, query, *args, &block
-                                                    )
+                                                   )
+        elsif tree.group_by || tree.order_by || tree.limit.try(:value).to_i > 0
+          raise CannotSpecifyShardError, "cannot specify shard for query: #{tree.to_sql}"
+        elsif shard_keys.present?
+          if SQLTree::Node::SelectDeclaration === tree.select.first &&
+             SQLTree::Node::CountAggregrate === tree.select.first.expression
+            return Fader::CalculateShardsSumResult.new(@proxy,
+                                                       build_shards_with_same_query(@proxy.shards.values, query),
+                                                       method, query, *args, &block)
+          else
+            return Fader::SelectShardsMergeResult.new(@proxy,
+                                                      Hash[shard_keys.map { |k| [@proxy.cluster.shard_for(k), query] }],
+                                                      method, query, *args, &block
+                                                     )
+          end
+        else # scan all shards
+          if SQLTree::Node::SelectDeclaration === tree.select.first &&
+             SQLTree::Node::CountAggregrate === tree.select.first.expression
+
+            if raise_on_not_specified_shard_query?
+              raise CannotSpecifyShardError, "[Performance Notice] PLEASE FIX: #{tree.to_sql}"
+            end
+            return Fader::CalculateShardsSumResult.new(@proxy,
+                                                       build_shards_with_same_query(@proxy.shards.values, query),
+                                                       method, query, *args, &block)
+          elsif SQLTree::Node::AllFieldsDeclaration === tree.select.first ||
+                SQLTree::Node::Expression::Value === tree.select.first.expression ||
+                SQLTree::Node::Expression::Variable === tree.select.first.expression
+
+            if raise_on_not_specified_shard_query?
+              raise CannotSpecifyShardError, "[Performance Notice] PLEASE FIX: #{tree.to_sql}"
+            end
+            return Fader::SelectShardsMergeResult.new(@proxy,
+                                                      build_shards_with_same_query(@proxy.shards.values, query),
+                                                      method, query, *args, &block
+                                                     )
+          else
+            raise CannotSpecifyShardError, "cannot specify shard for query: #{tree.to_sql}"
+          end
         end
-      else # scan all shards
-        if SQLTree::Node::SelectDeclaration === tree.select.first and
-            SQLTree::Node::CountAggregrate === tree.select.first.expression
+      end
 
-          if raise_on_not_specified_shard_query?
-            raise CannotSpecifyShardError, "[Performance Notice] PLEASE FIX: #{tree.to_sql}"
-          end
-          return Fader::CalculateShardsSumResult.new(@proxy,
-                                                     build_shards_with_same_query(@proxy.shards.values, query),
-                                                     method, query, *args, &block)
-        elsif SQLTree::Node::AllFieldsDeclaration === tree.select.first or
-            SQLTree::Node::Expression::Value === tree.select.first.expression or
-            SQLTree::Node::Expression::Variable === tree.select.first.expression
-
-          if raise_on_not_specified_shard_query?
+      def build_update_fader(tree, method, query, *args, &block)
+        shard_keys = find_shard_keys(tree.where, @proxy.klass.table_name, @proxy.klass.turntable_shard_key.to_s)
+        shards_with_query = if shard_keys.present?
+                              build_shards_with_same_query(shard_keys.map { |k| @proxy.cluster.shard_for(k) }, query)
+                            else
+                              build_shards_with_same_query(@proxy.shards.values, query)
+                            end
+
+        if shards_with_query.size == 1
+          Fader::SpecifiedShard.new(@proxy,
+                                    shards_with_query,
+                                    method, query, *args, &block)
+        else
+          if raise_on_not_specified_shard_update?
             raise CannotSpecifyShardError, "[Performance Notice] PLEASE FIX: #{tree.to_sql}"
           end
-          return Fader::SelectShardsMergeResult.new(@proxy,
-                                                    build_shards_with_same_query(@proxy.shards.values, query),
-                                                    method, query, *args, &block
-                                                    )
-        else
-          raise CannotSpecifyShardError, "cannot specify shard for query: #{tree.to_sql}"
+          Fader::UpdateShardsMergeResult.new(@proxy,
+                                             shards_with_query,
+                                             method, query, *args, &block)
         end
       end
-    end
 
-    def build_update_fader(tree, method, query, *args, &block)
-      shard_keys = find_shard_keys(tree.where, @proxy.klass.table_name, @proxy.klass.turntable_shard_key.to_s)
-      shards_with_query = if shard_keys.present?
-                            build_shards_with_same_query(shard_keys.map {|k| @proxy.cluster.shard_for(k) }, query)
-                          else
-                            build_shards_with_same_query(@proxy.shards.values, query)
-                          end
-
-      if shards_with_query.size == 1
-        Fader::SpecifiedShard.new(@proxy,
-                                  shards_with_query,
-                                  method, query, *args, &block)
-      else
-        if raise_on_not_specified_shard_update?
-          raise CannotSpecifyShardError, "[Performance Notice] PLEASE FIX: #{tree.to_sql}"
+      def build_insert_fader(tree, method, query, *args, &block)
+        values_hash = divide_insert_values(tree, @proxy.klass.turntable_shard_key)
+        shards_with_query = {}
+        values_hash.each do |k, vs|
+          tree.values = [[SQLTree::Node::Expression::Variable.new("\\0")]]
+          sql = tree.to_sql
+          value_sql = vs.map do |val|
+            "(#{val.map { |v| "#{v.escape}#{@proxy.connection.quote(v.value)}" }.join(', ')})"
+          end.join(", ")
+          sql.gsub!('("\0")') { value_sql }
+          shards_with_query[@proxy.cluster.shard_for(k)] = sql
         end
-        Fader::UpdateShardsMergeResult.new(@proxy,
-                                           shards_with_query,
-                                           method, query, *args, &block)
+        Fader::InsertShardsMergeResult.new(@proxy, shards_with_query, method, query, *args, &block)
       end
-    end
 
-    def build_insert_fader(tree, method, query, *args, &block)
-      values_hash = divide_insert_values(tree, @proxy.klass.turntable_shard_key)
-      shards_with_query = {}
-      values_hash.each do |k,vs|
-        tree.values = [[SQLTree::Node::Expression::Variable.new("\\0")]]
-        sql = tree.to_sql
-        value_sql = vs.map do |val|
-          "(#{val.map { |v| "#{v.escape}#{@proxy.connection.quote(v.value)}" }.join(', ')})"
-        end.join(', ')
-        sql.gsub!('("\0")') { value_sql }
-        shards_with_query[@proxy.cluster.shard_for(k)] = sql
+      def raise_on_not_specified_shard_query?
+        ActiveRecord::Base.turntable_config[:raise_on_not_specified_shard_query]
       end
-      Fader::InsertShardsMergeResult.new(@proxy, shards_with_query, method, query, *args, &block)
-    end
 
-    def raise_on_not_specified_shard_query?
-      ActiveRecord::Base.turntable_config[:raise_on_not_specified_shard_query]
-    end
-
-    def raise_on_not_specified_shard_update?
-      ActiveRecord::Base.turntable_config[:raise_on_not_specified_shard_update]
-    end
+      def raise_on_not_specified_shard_update?
+        ActiveRecord::Base.turntable_config[:raise_on_not_specified_shard_update]
+      end
   end
 end

data/lib/active_record/turntable/plugin.rb

@@ -1,4 +1,4 @@
-require 'active_record/turntable'
+require "active_record/turntable"
 
 module ActiveRecord::Turntable
   module Plugin

data/lib/active_record/turntable/pool_proxy.rb

@@ -1,22 +1,10 @@
 module ActiveRecord::Turntable
-  module ActiveRecordConnectionMethods
-    def self.included(base)
-      base.alias_method_chain :reload, :master
-    end
-
-    def reload_with_master(*args, &block)
-      connection.with_master { reload_without_master }
-    end
-  end
-
   class PoolProxy
     def initialize(proxy)
       @proxy = proxy
     end
 
-    def proxy
-      @proxy
-    end
+    attr_reader :proxy
     alias_method :connection, :proxy
 
     def with_connection
@@ -24,7 +12,7 @@ module ActiveRecord::Turntable
     end
 
     delegate :connected?, :automatic_reconnect, :automatic_reconnect=, :checkout_timeout, :dead_connection_timeout,
-               :spec, :connections, :size, :reaper, :table_exists?, to: :proxy
+             :spec, :connections, :size, :reaper, :table_exists?, to: :proxy
 
     %w(columns_hash column_defaults primary_keys).each do |name|
       define_method(name.to_sym) do
@@ -39,12 +27,12 @@ module ActiveRecord::Turntable
     end
 
     %w(active_connection?).each do |name|
-      define_method(name.to_sym) do |*args|
+      define_method(name.to_sym) do |*_args|
         @proxy.master.connection_pool.send(name.to_sym) ||
-        @proxy.seq.connection_pool.try(name.to_sym) if @proxy.respond_to?(:seq) ||
-        @proxy.shards.values.any? do |pool|
-          pool.connection_pool.send(name.to_sym)
-        end
+          @proxy.seq.connection_pool.try(name.to_sym) if @proxy.respond_to?(:seq) ||
+                                                         @proxy.shards.values.any? do |pool|
+                                                           pool.connection_pool.send(name.to_sym)
+                                                         end
       end
     end
 

data/lib/active_record/turntable/query_cache.rb

@@ -0,0 +1,41 @@
+require "rack/body_proxy"
+require "active_record/query_cache"
+
+module ActiveRecord
+  module Turntable
+    class QueryCache < ActiveRecord::QueryCache
+      def self.run
+        klasses = ActiveRecord::Base.turntable_connections.values
+        enables = klasses.map do |k|
+          enabled = k.connection.query_cache_enabled
+          k.connection.enable_query_cache!
+
+          enabled
+        end
+
+        enables.all?
+      end
+
+      def self.complete(enabled)
+        klasses =  ActiveRecord::Base.turntable_connections.values
+        klasses.each do |k|
+          k.connection.clear_query_cache
+          k.connection.disable_query_cache! unless enabled
+        end
+      end
+
+      def self.install_executor_hooks(executor = ActiveSupport::Executor)
+        executor.register_hook(self)
+
+        executor.to_complete do
+          klasses = ActiveRecord::Base.turntable_connection_classes
+          klasses.each do |k|
+            unless k.connected? && k.connection.transaction_open?
+              k.clear_active_connections!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/turntable/railtie.rb

@@ -1,14 +1,14 @@
 module ActiveRecord::Turntable
   class Railtie < Rails::Railtie
     rake_tasks do
-      require 'active_record/turntable/active_record_ext/database_tasks'
+      require "active_record/turntable/active_record_ext/database_tasks"
       load "active_record/turntable/railties/databases.rake"
     end
 
     # rails loading hook
     ActiveSupport.on_load(:before_initialize) do
       ActiveSupport.on_load(:active_record) do
-        ActiveRecord::Base.send(:include, ActiveRecord::Turntable)
+        ActiveRecord::Base.include(ActiveRecord::Turntable)
       end
     end
 
@@ -23,9 +23,11 @@ module ActiveRecord::Turntable
       end
     end
 
-    # QueryCache Middleware for turntable shards
-    initializer "turntable.insert_query_cache_middleware" do |app|
-      app.middleware.insert_after ActiveRecord::QueryCache, ActiveRecord::Turntable::Rack::QueryCache
+    # set QueryCache executor hooks for turntable clusters
+    initializer "active_record.set_executor_hooks" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Turntable::QueryCache.install_executor_hooks
+      end
     end
   end
 end

data/lib/active_record/turntable/railties/databases.rake

@@ -1,5 +1,5 @@
-require 'active_record/turntable'
-ActiveRecord::SchemaDumper.send(:include, ActiveRecord::Turntable::ActiveRecordExt::SchemaDumper)
+require "active_record/turntable"
+ActiveRecord::SchemaDumper.prepend(ActiveRecord::Turntable::ActiveRecordExt::SchemaDumper)
 
 turntable_namespace = nil
 
@@ -11,9 +11,9 @@ db_namespace = namespace :db do
       end
     end
 
-    desc 'Create current turntable databases config/database.yml for the current Rails.env'
+    desc "Create current turntable databases config/database.yml for the current Rails.env"
     task :create do
-      unless ENV['DATABASE_URL']
+      unless ENV["DATABASE_URL"]
         ActiveRecord::Tasks::DatabaseTasks.create_current_turntable_cluster
       end
     end
@@ -24,9 +24,9 @@ db_namespace = namespace :db do
       end
     end
 
-    desc 'Drops current turntable databases for the current Rails.env'
+    desc "Drops current turntable databases for the current Rails.env"
     task :drop do
-      unless ENV['DATABASE_URL']
+      unless ENV["DATABASE_URL"]
         ActiveRecord::Tasks::DatabaseTasks.drop_current_turntable_cluster
       end
     end
@@ -34,14 +34,14 @@ db_namespace = namespace :db do
     namespace :schema do
       # TODO: implement schema:cache:xxxx
       task :dump do
-        require 'active_record/schema_dumper'
+        require "active_record/schema_dumper"
         config = ActiveRecord::Base.configurations[Rails.env]
         shard_configs = config["shards"]
         shard_configs.merge!(config["seq"]) if config["seq"]
         if shard_configs
           shard_configs.each do |name, config|
             next unless config["database"]
-            filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema-#{name}.rb"
+            filename = ENV["SCHEMA"] || "#{Rails.root}/db/schema-#{name}.rb"
             File.open(filename, "w:utf-8") do |file|
               ActiveRecord::Base.establish_connection(config)
               ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
@@ -49,10 +49,10 @@ db_namespace = namespace :db do
           end
         end
         ActiveRecord::Base.establish_connection(config)
-        turntable_namespace['schema:dump'].reenable
+        turntable_namespace["schema:dump"].reenable
       end
 
-      desc 'Load a schema.rb file into the database'
+      desc "Load a schema.rb file into the database"
       task :load do
         config = ActiveRecord::Base.configurations[Rails.env]
         shard_configs = config["shards"]
@@ -61,11 +61,11 @@ db_namespace = namespace :db do
           shard_configs.each do |name, config|
             next unless config["database"]
             ActiveRecord::Base.establish_connection(config)
-            file = ENV['SCHEMA'] || "#{Rails.root}/db/schema-#{name}.rb"
-            if File.exists?(file)
+            file = ENV["SCHEMA"] || "#{Rails.root}/db/schema-#{name}.rb"
+            if File.exist?(file)
               load(file)
             else
-              abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded'}
+              abort %(#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded')
             end
           end
         end
@@ -74,7 +74,7 @@ db_namespace = namespace :db do
     end
 
     namespace :structure do
-      desc 'Dump the database structure to an SQL file'
+      desc "Dump the database structure to an SQL file"
       task :dump do
         current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
         shard_configs = current_config["shards"]
@@ -86,15 +86,14 @@ db_namespace = namespace :db do
             filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure_#{name}.sql")
             ActiveRecord::Tasks::DatabaseTasks.structure_dump(config, filename)
 
-            if ActiveRecord::Base.connection.supports_migrations?
-              File.open(filename, "a") do |f|
-                f.puts ActiveRecord::Base.connection.dump_schema_information
-              end
+            next unless ActiveRecord::Base.connection.supports_migrations?
+            File.open(filename, "a") do |f|
+              f.puts ActiveRecord::Base.connection.dump_schema_information
             end
           end
           ActiveRecord::Base.establish_connection(current_config)
         end
-        turntable_namespace['structure:dump'].reenable
+        turntable_namespace["structure:dump"].reenable
       end
 
       # desc "Recreate the databases from the structure.sql file"
@@ -121,7 +120,7 @@ db_namespace = namespace :db do
         shard_configs = config["shards"]
         shard_configs.merge!(config["seq"]) if config["seq"]
         if shard_configs
-          shard_configs.each do |name, config|
+          shard_configs.each do |_name, config|
             next unless config["database"]
             ActiveRecord::Tasks::DatabaseTasks.purge config
           end

data/lib/active_record/turntable/seq_shard.rb

@@ -2,20 +2,20 @@ module ActiveRecord::Turntable
   class SeqShard < Shard
     private
 
-    def create_connection_class
-      klass = get_or_set_connection_class
-      klass.remove_connection
-      klass.establish_connection ActiveRecord::Base.connection_pool.spec.config[:seq][name].with_indifferent_access
-      klass
-    end
- 
-    def retrieve_connection_pool
-      ActiveRecord::Base.turntable_connections[name] ||=
-        begin
-          config = ActiveRecord::Base.configurations[Rails.env]["seq"][name]
-          raise ArgumentError, "Unknown database config: #{name}, have #{ActiveRecord::Base.configurations.inspect}" unless config
-          ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec_for(config))
-        end
-    end
+      def create_connection_class
+        klass = get_or_set_connection_class
+        klass.remove_connection
+        klass.establish_connection ActiveRecord::Base.connection_pool.spec.config[:seq][name].with_indifferent_access
+        klass
+      end
+
+      def retrieve_connection_pool
+        ActiveRecord::Base.turntable_connections[name] ||=
+          begin
+            config = ActiveRecord::Base.configurations[Rails.env]["seq"][name]
+            raise ArgumentError, "Unknown database config: #{name}, have #{ActiveRecord::Base.configurations.inspect}" unless config
+            ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec_for(config))
+          end
+      end
   end
 end