activerecord-turntable 1.1.2 → 2.0.0.rc1

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

@@ -0,0 +1,31 @@
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module Relation
+      extend ActiveSupport::Concern
+
+      included do
+        version = ActiveRecord::VERSION::STRING
+        if version >= '4.1'
+          if version < '4.1.2'
+            alias_method :_update_record_without_turntable, :update_record
+            alias_method :update_record, :_update_record_with_turntable
+          else
+            alias_method_chain :_update_record, :turntable
+          end
+        end
+      end
+
+      def _update_record_with_turntable(values, id, id_was, turntable_scope = nil) # :nodoc:
+        substitutes, binds = substitute_values values
+        condition_scope = @klass.unscoped.where(@klass.arel_table[@klass.primary_key].eq(id_was || id))
+        condition_scope = condition_scope.merge(turntable_scope) if turntable_scope
+        um = condition_scope.arel.compile_update(substitutes, @klass.primary_key)
+
+        @klass.connection.update(
+          um,
+          'SQL',
+          binds)
+      end
+    end
+  end
+end

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

@@ -22,51 +22,41 @@ module ActiveRecord::Turntable
             pk = @connection.primary_key(table)
           end
 
-          # turntable sequencer dump
           if table =~ /\A(.*)_id_seq\z/
-            tbl.print "  create_sequence_for #{$1.inspect}"
+            tbl.print "  create_sequence_for #{remove_prefix_and_suffix($1).inspect}"
           else
-            tbl.print "  create_table #{table.inspect}"
+            tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
           end
-
-          if columns.detect { |c| c.name == pk }
+          pkcol = columns.detect { |c| c.name == pk }
+          if pkcol
             if pk != 'id'
-              tbl.print %Q(, :primary_key => "#{pk}")
+              tbl.print %Q(, primary_key: "#{pk}")
+            elsif pkcol.sql_type == 'uuid'
+              tbl.print ", id: :uuid"
+              tbl.print %Q(, default: "#{pkcol.default_function}") if pkcol.default_function
             end
           else
-            tbl.print ", :id => false"
+            tbl.print ", id: false"
           end
-          tbl.print ", :force => true"
+          tbl.print ", force: true"
           tbl.puts " do |t|"
 
           # then dump all non-primary key columns
           column_specs = columns.map do |column|
-            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
-            spec = {}
-            spec[:name]      = column.name.inspect
-
-            # AR has an optimisation which handles zero-scale decimals as integers.  This
-            # code ensures that the dumper still dumps the column as a decimal.
-            spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
-                                 'decimal'
-                               else
-                                 column.type.to_s
-                               end
-            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
-            spec[:precision] = column.precision.inspect if column.precision
-            spec[:scale]     = column.scale.inspect if column.scale
-            spec[:null]      = 'false' unless column.null
-            spec[:default]   = default_string(column.default) if column.has_default?
-            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
-            spec
+            @connection.column_spec(column, @types)
           end.compact
 
           # find all migration keys used in this table
-          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten
+          keys = @connection.migration_keys
 
           # figure out the lengths for each column based on above keys
-          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+          lengths = keys.map { |key|
+            column_specs.map { |spec|
+              spec[key] ? spec[key].length + 2 : 0
+            }.max
+          }
 
           # the string we're going to sprintf our values against, with standardized column widths
           format_string = lengths.map{ |len| "%-#{len}s" }

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

@@ -5,12 +5,18 @@ module ActiveRecord::Turntable
         if self.class.turntable_enabled?
           status = nil
           if self.new_record? and self.turntable_shard_key.to_s == self.class.primary_key and
-              self.id.nil? and connection.prefetch_primary_key?(self.class.table_name)
-            self.id = connection.next_sequence_value(self.class.sequence_name)
+              self.id.nil? and 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
-            status = yield
+            begin
+              status = yield
+            rescue ActiveRecord::Rollback
+              @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+              status = nil
+            end
+
             raise ActiveRecord::Rollback unless status
           end
           status

data/lib/active_record/turntable/active_record_ext.rb

@@ -1,14 +1,22 @@
 module ActiveRecord::Turntable
   module ActiveRecordExt
     extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
 
-    autoload :AbstractAdapter, 'active_record/turntable/active_record_ext/abstract_adapter'
-    autoload :CleverLoad, 'active_record/turntable/active_record_ext/clever_load'
-    autoload :LogSubscriber, 'active_record/turntable/active_record_ext/log_subscriber'
-    autoload :Persistence, 'active_record/turntable/active_record_ext/persistence'
-    autoload :SchemaDumper, 'active_record/turntable/active_record_ext/schema_dumper'
-    autoload :Sequencer, 'active_record/turntable/active_record_ext/sequencer'
-    autoload :Transactions, 'active_record/turntable/active_record_ext/transactions'
+    eager_autoload do
+      autoload :AbstractAdapter
+      autoload :CleverLoad
+      autoload :ConnectionHandlerExtension
+      autoload :LogSubscriber
+      autoload :Persistence
+      autoload :SchemaDumper
+      autoload :Sequencer
+      autoload :Relation
+      autoload :Transactions
+      autoload :AssociationPreloader
+      autoload :Association
+      autoload :LockingOptimistic
+    end
 
     included do
       include Transactions
@@ -16,11 +24,18 @@ module ActiveRecord::Turntable
       ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, AbstractAdapter)
       ActiveRecord::LogSubscriber.send(:include, LogSubscriber)
       ActiveRecord::Persistence.send(:include, Persistence)
-      ActiveRecord::Relation.send(:include, CleverLoad)
-      ActiveRecord::VERSION::STRING < '3.1' ?
-        ActiveRecord::Migration.extend(ActiveRecord::Turntable::Migration) :
-        ActiveRecord::Migration.send(:include, ActiveRecord::Turntable::Migration)
+      ActiveRecord::Locking::Optimistic.send(:include, LockingOptimistic)
+      ActiveRecord::Relation.send(:include, CleverLoad, Relation)
+      ActiveRecord::Migration.send(:include, ActiveRecord::Turntable::Migration)
+      ActiveRecord::ConnectionAdapters::ConnectionHandler.instance_exec do
+        include ConnectionHandlerExtension
+      end
+      ActiveRecord::Associations::Preloader::Association.send(:include, AssociationPreloader)
+      ActiveRecord::Associations::Association.send(:include, Association)
       require 'active_record/turntable/active_record_ext/fixtures'
+      require 'active_record/turntable/active_record_ext/migration_proxy'
+      require 'active_record/turntable/active_record_ext/activerecord_import_ext'
+      require 'active_record/turntable/active_record_ext/acts_as_archive_extension'
     end
   end
 end

data/lib/active_record/turntable/algorithm/base.rb

@@ -5,7 +5,7 @@ module ActiveRecord::Turntable::Algorithm
     end
 
     def calculate(key)
-      raise ActiveRecord::Turntable::NotImplementedError, "not implemented"
+      raise NotImplementedError, "not implemented"
     end
   end
 end

data/lib/active_record/turntable/algorithm/range_bsearch_algorithm.rb

@@ -15,7 +15,7 @@ module ActiveRecord::Turntable::Algorithm
     end
 
     def calculate_idx(key)
-      @config["shards"].bsearch_lower_boundary { |h|
+      @config["shards"].bsearch_upper_boundary { |h|
         h["less_than"] <=> key
       }
     end

data/lib/active_record/turntable/algorithm.rb

@@ -1,7 +1,11 @@
 module ActiveRecord::Turntable
   module Algorithm
-    autoload :Base, "active_record/turntable/algorithm/base"
-    autoload :RangeAlgorithm, "active_record/turntable/algorithm/range_algorithm"
-    autoload :RangeBsearchAlgorithm, "active_record/turntable/algorithm/range_bsearch_algorithm"
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Base
+      autoload :RangeAlgorithm
+      autoload :RangeBsearchAlgorithm
+    end
   end
 end

data/lib/active_record/turntable/base.rb

@@ -3,15 +3,15 @@ module ActiveRecord::Turntable
     extend ActiveSupport::Concern
 
     included do
-      include Compatible
-      class_attribute :turntable_connections,
+      class_attribute :turntable_connections, :turntable_clusters,
                         :turntable_enabled, :turntable_sequencer_enabled
 
       self.turntable_connections = {}
+      self.turntable_clusters = Hash.new {|h,k| h[k]={}}
       self.turntable_enabled = false
       self.turntable_sequencer_enabled = false
       class << self
-        delegate :shards_transaction, :to => :connection
+        delegate :shards_transaction, :with_all, :to => :connection
       end
     end
 
@@ -28,7 +28,10 @@ module ActiveRecord::Turntable
                                    turntable_config[:clusters][cluster_name],
                                    options
                                  )
+        self.turntable_clusters[cluster_name][self] = turntable_cluster
+
         turntable_replace_connection_pool
+        turntable_define_cluster_methods(cluster_name)
       end
 
       def force_transaction_all_shards!(options={}, &block)
@@ -51,7 +54,8 @@ module ActiveRecord::Turntable
 
       def force_connect_all_shards!
         conf = configurations[Rails.env]
-        shards = conf["shards"]
+        shards = {}
+        shards = shards.merge(conf["shards"]) if conf["shards"]
         shards = shards.merge(conf["seq"]) if conf["seq"]
         shards.each do |name, config|
           turntable_connections[name] ||=
@@ -62,12 +66,9 @@ module ActiveRecord::Turntable
       def turntable_replace_connection_pool
         ch = connection_handler
         cp = turntable_cluster.connection_proxy
-        if ActiveRecord::VERSION::STRING >= '3.2.0'
-          ch.connection_pools[cp.spec] = PoolProxy.new(cp)
-          ch.instance_variable_get(:@class_to_pool)[name] = ch.connection_pools[cp.spec]
-        else
-          ch.connection_pools[name] = PoolProxy.new(cp)
-        end
+        pp = PoolProxy.new(cp)
+        ch.class_to_pool.clear if defined?(ch.class_to_pool)
+        ch.send(:class_to_pool)[name] = ch.send(:owner_to_pool)[name] = pp
       end
 
       def spec_for(config)
@@ -77,7 +78,7 @@ module ActiveRecord::Turntable
           raise "Please install the #{config['adapter']} adapter: `gem install activerecord-#{config['adapter']}-adapter` (#{e})"
         end
         adapter_method = "#{config['adapter']}_connection"
-        ActiveRecord::Base::ConnectionSpecification.new(config, adapter_method)
+        ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(config, adapter_method)
       end
 
       def clear_all_connections!
@@ -86,10 +87,11 @@ module ActiveRecord::Turntable
         end
       end
 
-      def sequencer
+      def sequencer(sequence_name, *args)
         class_attribute :turntable_sequencer
+
         self.turntable_sequencer_enabled = true
-        self.turntable_sequencer = ActiveRecord::Turntable::Sequencer.build(self)
+        self.turntable_sequencer = ActiveRecord::Turntable::Sequencer.build(self, sequence_name, *args)
       end
 
       def turntable_enabled?
@@ -117,6 +119,53 @@ module ActiveRecord::Turntable
         }
         self.connection.with_recursive_shards(shard.name, *klasses, &block)
       end
+
+      def with_shard(any_shard)
+        shard = case any_shard
+                when Numeric
+                  turntable_cluster.shard_for(any_shard)
+                when ActiveRecord::Base
+                  turntable_cluster.shard_for(any_shard.send(any_shard.turntable_shard_key))
+                else
+                  shard_or_key
+                end
+        connection.with_shard(shard) { yield }
+      end
+
+      private
+
+      def turntable_define_cluster_methods(cluster_name)
+        turntable_define_cluster_class_methods(cluster_name)
+      end
+
+      def turntable_define_cluster_class_methods(cluster_name)
+        (class << ActiveRecord::Base; self; end).class_eval <<-EOD
+          unless respond_to?(:#{cluster_name}_transaction)
+            def #{cluster_name}_transaction(shards = [], options = {})
+              cluster = turntable_clusters[#{cluster_name.inspect}].values.first
+              cluster.shards_transaction(shards, options) { yield }
+            end
+          end
+
+          unless respond_to?(:all_cluster_transaction)
+            def all_cluster_transaction(options = {})
+              clusters = turntable_clusters.values.map { |v| v.values.first }
+              recursive_cluster_transaction(clusters) { yield }
+            end
+
+            def recursive_cluster_transaction(clusters, options = {}, &block)
+              current_cluster = clusters.shift
+              current_cluster.shards_transaction do
+                if clusters.present?
+                  recursive_cluster_transaction(clusters, options, &block)
+                else
+                  yield
+                end
+              end
+            end
+          end
+        EOD
+      end
     end
 
     def shards_transaction(options = {}, &block)
@@ -124,7 +173,11 @@ module ActiveRecord::Turntable
     end
 
     def turntable_shard
-      turntable_cluster.select_shard(self.send(turntable_shard_key))
+      turntable_cluster.shard_for(self.send(turntable_shard_key))
+    end
+
+    def with_shard(shard)
+      self.class.connection.with_shard(shard) { yield }
     end
   end
 end

data/lib/active_record/turntable/cluster.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
 module ActiveRecord::Turntable
   class Cluster
 
@@ -16,7 +18,7 @@ module ActiveRecord::Turntable
       @master_shard = MasterShard.new(klass)
 
       # setup sequencer
-      if (seq = (@options[:seq] || @config[:seq]))
+      if (seq = (@options[:seq] || @config[:seq])) && seq[:type] == :mysql
         @seq_shard = SeqShard.new(seq)
       end
 
@@ -53,13 +55,55 @@ module ActiveRecord::Turntable
       @connection_proxy
     end
 
-    def select_shard(key)
+    def shard_for(key)
       @shards[@algorithm.calculate(key)]
     rescue
       raise ActiveRecord::Turntable::CannotSpecifyShardError,
       "[#{klass}] cannot select_shard for key:#{key}"
     end
 
+    def select_shard(key)
+      ActiveSupport::Deprecation.warn "Cluster#select_shard is deprecated, use shard_for() instead.", caller
+      shard_for(key)
+    end
+
+    def shards_transaction(shards = [], options = {}, in_recursion = false, &block)
+      unless in_recursion
+        shards = Array.wrap(shards).dup
+        if shards.blank?
+          shards = @shards.values.dup
+        end
+      end
+      shard_or_object = shards.shift
+      shard = to_shard(shard_or_object)
+      if shards.present?
+        shard.connection.transaction(options) do
+          shards_transaction(shards, options, true, &block)
+        end
+      else
+        shard.connection.transaction(options) do
+          block.call
+        end
+      end
+    end
+
+    def to_shard(shard_or_object)
+      case shard_or_object
+      when ActiveRecord::Turntable::Shard
+        shard_or_object
+      when ActiveRecord::Base
+        shard_or_object.turntable_shard
+      when Numeric, String
+        shard_for(shard_or_object)
+      when Symbol
+        shards[shard_or_object]
+      else
+        binding.pry
+        raise ActiveRecord::Turntable::TurntableError,
+                "transaction cannot call to object: #{shard_or_object}"
+      end
+    end
+
     def weighted_shards(key = nil)
       key ||= @klass.current_sequence
       Hash[@algorithm.calculate_used_shards_with_weight(key).map do |k,v|

data/lib/active_record/turntable/config.rb

@@ -18,7 +18,7 @@ module ActiveRecord::Turntable
     end
 
     def load!(config_file, env)
-      @config = YAML.load_file(config_file).with_indifferent_access[env]
+      @config = YAML.load(ERB.new(IO.read(config_file)).result).with_indifferent_access[env]
     end
   end
 end

data/lib/active_record/turntable/connection_proxy/mixable.rb

@@ -3,36 +3,14 @@ module ActiveRecord::Turntable
     module Mixable
       extend ActiveSupport::Concern
 
-      included do
-        if ActiveRecord::VERSION::STRING < '3.1'
-          include Rails30
-        else
-          include Rails3x
-        end
-      end
-
-      module Rails3x
-        METHODS_REGEXP = /\A(insert|select|update|delete|exec_)/
-        EXCLUDE_QUERY_REGEXP = /\A\s*SHOW/i
-        QUERY_REGEXP = /\A\s*(INSERT|DELETE|UPDATE|SELECT)/i
-
-        def mixable?(method, *args)
-          (method.to_s =~ METHODS_REGEXP &&
-           args.first !~ EXCLUDE_QUERY_REGEXP) ||
-            (method.to_s == 'execute' && args.first =~ QUERY_REGEXP)
-        end
-      end
-
-      module Rails30
-        METHODS_REGEXP = /\A(insert|select|update|delete)/
-        EXCLUDE_QUERY_REGEXP = /\A\s*SHOW/i
-        QUERY_REGEXP = /\A\s*(INSERT|DELETE|UPDATE|SELECT)/i
+      METHODS_REGEXP = /\A(insert|select|update|delete|exec_)/
+      EXCLUDE_QUERY_REGEXP = /\A\s*SHOW/i
+      QUERY_REGEXP = /\A\s*(INSERT|DELETE|UPDATE|SELECT)/i
 
-        def mixable?(method, *args)
-          (method.to_s =~ METHODS_REGEXP &&
-           args.first !~ EXCLUDE_QUERY_REGEXP) ||
-            (method.to_s == 'execute' && args.first =~ QUERY_REGEXP)
-        end
+      def mixable?(method, *args)
+        (method.to_s =~ METHODS_REGEXP &&
+         args.first !~ EXCLUDE_QUERY_REGEXP) ||
+          (method.to_s == 'execute' && args.first =~ QUERY_REGEXP)
       end
     end
   end