activerecord-turntable 1.1.2 → 2.0.0.rc1

data/Rakefile

@@ -7,6 +7,9 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
+require 'active_record'
+require "active_record/turntable/active_record_ext/database_tasks"
+
 namespace :turntable do
   namespace :db do
     task :rails_env do
@@ -16,32 +19,34 @@ namespace :turntable do
     end
 
     task :load_config => :rails_env do
-      require 'active_record'
-      ActiveRecord::Base.configurations = YAML.load_file(File.join(File.dirname(__FILE__), 'spec/config/database.yml'))
+      yaml_file = File.join(File.dirname(__FILE__), 'spec/config/database.yml')
+      ActiveRecord::Base.configurations = YAML.load ERB.new(IO.read(yaml_file)).result
     end
 
     desc "create turntable test database"
     task :create => :load_config do
-      database_configs = [ActiveRecord::Base.configurations[RAILS_ENV]] + ActiveRecord::Base.configurations[RAILS_ENV]["shards"].values + ActiveRecord::Base.configurations[RAILS_ENV]["seq"].values
-      database_configs.each do |dbconf|
-        command = "mysql "
-        command << "-u #{dbconf["username"]} " if dbconf["username"]
-        command << "-p#{dbconf["password"]} " if dbconf["password"]
-        command << "-h #{dbconf["host"]}" if dbconf["host"]
-        %x{ echo "CREATE DATABASE #{dbconf["database"]}" | #{command} }
-      end
+      ActiveRecord::Tasks::DatabaseTasks.create_current(RAILS_ENV)
+      ActiveRecord::Tasks::DatabaseTasks.create_current_turntable_cluster(RAILS_ENV)
+    end
+
+    desc "drop turntable test database"
+    task :drop => :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.drop_current(RAILS_ENV)
+      ActiveRecord::Tasks::DatabaseTasks.drop_current_turntable_cluster(RAILS_ENV)
     end
 
     desc "migrate turntable test tables"
     task :migrate => :load_config do
-      ActiveRecord::Base.establish_connection RAILS_ENV
+      ActiveRecord::Base.establish_connection RAILS_ENV.to_sym
       require 'active_record/turntable'
       ActiveRecord::Base.send(:include, ActiveRecord::Turntable)
       ActiveRecord::ConnectionAdapters::SchemaStatements.send(:include, ActiveRecord::Turntable::Migration::SchemaStatementsExt)
-      database_configs = [ActiveRecord::Base.configurations[RAILS_ENV]] + ActiveRecord::Base.configurations[RAILS_ENV]["shards"].values + ActiveRecord::Base.configurations[RAILS_ENV]["seq"].values
 
-      database_configs.each do |dbconf|
-        ActiveRecord::Base.establish_connection dbconf
+      configurations = [ActiveRecord::Base.configurations[RAILS_ENV]]
+      configurations += ActiveRecord::Tasks::DatabaseTasks.current_turntable_cluster_configurations(RAILS_ENV).map {|v| v[1]}.flatten.uniq
+
+      configurations.each do |configuration|
+        ActiveRecord::Base.establish_connection configuration
 
         ActiveRecord::Base.connection.create_table :users do |t|
           t.string :nickname
@@ -56,6 +61,7 @@ namespace :turntable do
           t.belongs_to :user, :null => false
           t.integer    :hp,   :null => false, :default => 0
           t.integer    :mp,   :null => false, :default => 0
+          t.integer    :lock_version, :null => false, :default => 0
           t.datetime   :deleted_at, :default => nil
           t.timestamps
         end
@@ -89,21 +95,30 @@ namespace :turntable do
           t.datetime   :deleted_at, :default => nil
         end
         ActiveRecord::Base.connection.create_sequence_for :archived_cards_users
+
+        ActiveRecord::Base.connection.create_table :cards_users_histories do |t|
+          t.belongs_to :cards_user,    :null => false
+          t.belongs_to :user,    :null => false
+          t.timestamps
+        end
+        ActiveRecord::Base.connection.create_sequence_for :cards_users_histories
+
+        ActiveRecord::Base.connection.create_table :events_users_histories do |t|
+          t.belongs_to :events_user,    :null => false
+          t.belongs_to :cards_user,    :null => false
+          t.belongs_to :user,    :null => false
+          t.timestamps
+        end
+        ActiveRecord::Base.connection.create_sequence_for :events_users_histories
       end
     end
 
     desc "drop turntable test database"
     task :drop => :load_config do
-      database_configs = [ActiveRecord::Base.configurations[RAILS_ENV]] + ActiveRecord::Base.configurations[RAILS_ENV]["shards"].values + ActiveRecord::Base.configurations[RAILS_ENV]["seq"].values
-      database_configs.each do |dbconf|
-        command = "mysql "
-        command << "-u #{dbconf["username"]} " if dbconf["username"]
-        command << "-p#{dbconf["password"]} " if dbconf["password"]
-        command << "-h #{dbconf["host"]}" if dbconf["host"]
-        %x{ echo "DROP DATABASE #{dbconf["database"]}" | #{command} }
-      end
+      ActiveRecord::Tasks::DatabaseTasks.drop_current_turntable_cluster(RAILS_ENV)
     end
 
+    desc "reset turntable test databases"
     task :reset => ["turntable:db:drop", "turntable:db:create", "turntable:db:migrate"]
   end
 end

data/activerecord-turntable.gemspec

@@ -1,48 +1,51 @@
 $:.push File.expand_path("../lib", __FILE__)
 require "active_record/turntable/version"
 
-Gem::Specification.new do |s|
-  s.name = "activerecord-turntable"
-  s.version = ActiveRecord::Turntable::VERSION
-  s.authors     = ["gussan"]
-  s.homepage    = "https://github.com/drecom/activerecord-turntable"
-  s.summary = %q{ActiveRecord Sharding plugin}
-  s.description = %q{ActiveRecord Sharding plugin}
+Gem::Specification.new do |spec|
+  spec.name = "activerecord-turntable"
+  spec.version = ActiveRecord::Turntable::VERSION
+  spec.authors     = ["gussan", "sue445"]
+  spec.homepage    = "https://github.com/drecom/activerecord-turntable"
+  spec.summary = %q{ActiveRecord sharding extension}
+  spec.description = %q{ActiveRecord sharding extension}
+  spec.license = "MIT"
 
-  s.rubyforge_project = "activerecord-turntable"
-  s.extra_rdoc_files = [
+  spec.rubyforge_project = "activerecord-turntable"
+  spec.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "CHANGELOG.md"
   ]
 
-  s.files         = `git ls-files | grep -v "^spec"`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.licenses = ["MIT"]
-  s.rubygems_version = "1.8.16"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  # runtime dependencies
-  s.add_runtime_dependency(%q<activerecord>, [">= 3.0.0"])
-  s.add_runtime_dependency(%q<activesupport>, [">=3.0.0"])
-  s.add_runtime_dependency(%q<sql_tree>, ["= 0.2.0"])
-  s.add_runtime_dependency(%q<bsearch>, ["~> 1.5"])
-  s.add_runtime_dependency(%q<httpclient>, [">= 0"])
+  spec.add_dependency "activerecord",  ">= 4.0.0"
+  spec.add_dependency "activesupport", ">= 4.0.0"
+  spec.add_dependency "sql_tree",      "= 0.2.0"
+  spec.add_dependency "bsearch",       "~> 1.5"
+  spec.add_dependency "httpclient",    ">= 0"
 
-  # development dependencies
-  s.add_development_dependency(%q<rake>, ["~> 10.0.3"])
-  s.add_development_dependency(%q<rspec>, [">= 0"])
-  s.add_development_dependency(%q<rr>, [">= 0"])
-  s.add_development_dependency(%q<mysql2>, [">= 0"])
-  s.add_development_dependency(%q<fabrication>, [">= 0"])
-  s.add_development_dependency(%q<faker>, [">= 0"])
-  s.add_development_dependency(%q<activerecord-import>, [">= 0"])
-  s.add_development_dependency(%q<pry>, [">= 0"])
-  s.add_development_dependency(%q<guard-rspec>, [">= 0"])
-  s.add_development_dependency(%q<coveralls>, [">= 0"])
+  # optional dependencies
+  spec.add_development_dependency "activerecord-import"
+  spec.add_development_dependency "barrage"
+  spec.add_development_dependency "mysql2"
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "rspec-collection_matchers"
+  spec.add_development_dependency "fabrication"
+  spec.add_development_dependency "faker"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "coveralls"
 
   if RUBY_PLATFORM =~ /darwin/
-    s.add_development_dependency(%q<growl>, [">= 0"])
+    spec.add_development_dependency "growl"
   end
 end

data/gemfiles/rails4_0.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'activerecord', "~> 4.0.0"
+gem 'activesupport', "~> 4.0.0"
+
+gemspec :path => '../'

data/gemfiles/rails4_1.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'activerecord', "~> 4.1.0"
+gem 'activesupport', "~> 4.1.0"
+
+gemspec :path => '../'

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

@@ -6,35 +6,20 @@ module ActiveRecord::Turntable
       included do
         protected
 
-        if ActiveRecord::VERSION::STRING < '3.1'
-          def log(sql, name)
-            name ||= "SQL"
-            @instrumenter.instrument("sql.active_record",
-                                     :sql => sql, :name => name, :connection_id => object_id,
-                                     :turntable_shard_name => turntable_shard_name) do
-              yield
-            end
-          rescue Exception => e
-            message = "#{e.class.name}: #{e.message}: #{sql} : #{turntable_shard_name}"
-            @logger.debug message if @logger
-            raise translate_exception(e, message)
-          end
-        else
-          def log(sql, name = "SQL", binds = [])
-            @instrumenter.instrument(
-                                     "sql.active_record",
-                                     :sql           => sql,
-                                     :name          => name,
-                                     :connection_id => object_id,
-                                     :binds         => binds,
-                                     :turntable_shard_name => turntable_shard_name) { yield }
-          rescue Exception => e
-            message = "#{e.class.name}: #{e.message}: #{sql} : #{turntable_shard_name}"
-            @logger.debug message if @logger
-            exception = translate_exception(e, message)
-            exception.set_backtrace e.backtrace
-            raise exception
-          end
+        def log(sql, name = "SQL", binds = [])
+          @instrumenter.instrument(
+                                   "sql.active_record",
+                                   :sql           => sql,
+                                   :name          => name,
+                                   :connection_id => object_id,
+                                   :binds         => binds,
+                                   :turntable_shard_name => turntable_shard_name) { yield }
+        rescue Exception => e
+          message = "#{e.class.name}: #{e.message}: #{sql} : #{turntable_shard_name}"
+          @logger.debug message if @logger
+          exception = translate_exception(e, message)
+          exception.set_backtrace e.backtrace
+          raise exception
         end
       end
 

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

@@ -0,0 +1,45 @@
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module ActiverecordImportExt
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :values_sql_for_columns_and_attributes, :turntable
+      end
+
+      private
+
+      def values_sql_for_columns_and_attributes_with_turntable(columns, array_of_attributes)
+        connection_memo = connection
+        array_of_attributes.map do |arr|
+          my_values = arr.each_with_index.map do |val,j|
+            column = columns[j]
+
+            # be sure to query sequence_name *last*, only if cheaper tests fail, because it's costly
+            if val.nil? && column.name == primary_key && !sequence_name.blank?
+              if sequencer_enabled?
+                connection_memo.next_sequence_value(sequence_name)
+              else
+                connection_memo.next_value_for_sequence(sequence_name)
+              end
+            else
+              if serialized_attributes.include?(column.name)
+                connection_memo.quote(serialized_attributes[column.name].dump(val), column)
+              else
+                connection_memo.quote(val, column)
+              end
+            end
+          end
+          "(#{my_values.join(',')})"
+        end
+      end
+    end
+
+    begin
+      require 'activerecord-import'
+      require 'activerecord-import/base'
+      (class << ActiveRecord::Base; self; end).send(:include, ActiverecordImportExt)
+    rescue LoadError
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+begin
+  require 'acts_as_archive'
+
+  class ActsAsArchive
+    class << self
+      def move_with_turntable(config, where, merge_options={})
+        if [config[:to], config[:from]].all? { |k| k.try(:turntable_enabled?) }
+          current_shard = config[:from].connection.current_shard.name.to_sym
+          config[:to].connection.with_shard(current_shard) {
+            move_without_turntable(config, where, merge_options)
+          }
+        else
+          move_without_turntable(config, where, merge_options)
+        end
+      end
+
+      alias_method_chain :move, :turntable
+    end
+  end
+rescue LoadError
+end

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

@@ -0,0 +1,85 @@
+require 'active_record/associations'
+
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module Association
+      extend ActiveSupport::Concern
+
+      included do
+        ActiveRecord::Associations::SingularAssociation.send(:include, SingularAssociationExt)
+        ActiveRecord::Associations::CollectionAssociation.send(:include, CollectionAssociationExt)
+        ActiveRecord::Associations::Builder::Association.valid_options += [:foreign_shard_key]
+      end
+
+      module SingularAssociationExt
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method_chain :find_target, :turntable
+        end
+
+        private
+
+        if ActiveRecord::Turntable.rails41_later?
+          def find_target_with_turntable
+            current_scope = scope
+            if should_use_shard_key?
+              current_scope = current_scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
+            end
+            if record = current_scope.take
+              set_inverse_instance record
+            end
+          end
+        else
+          def find_target_with_turntable
+            current_scope = scope
+            if should_use_shard_key?
+              current_scope = current_scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
+            end
+            current_scope.take.tap { |record| set_inverse_instance(record) }
+          end
+        end
+      end
+
+      module CollectionAssociationExt
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method_chain :find_target, :turntable
+        end
+
+        private
+
+        def find_target_with_turntable
+          records =
+            if options[:finder_sql]
+              reflection.klass.find_by_sql(custom_finder_sql)
+            else
+              current_scope = scope
+              if should_use_shard_key?
+                current_scope = current_scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
+              end
+              current_scope.to_a
+            end
+          records.each { |record| set_inverse_instance(record) }
+          records
+        end
+
+      end
+
+      private
+
+      def foreign_shard_key
+        options[:foreign_shard_key] || owner.turntable_shard_key
+      end
+
+      def should_use_shard_key?
+        same_association_shard_key? || !!options[:foreign_shard_key]
+      end
+
+      def same_association_shard_key?
+        owner.class.turntable_enabled? && klass.turntable_enabled? && foreign_shard_key == klass.turntable_shard_key
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'active_record/associations/preloader/association'
+
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module AssociationPreloader
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :records_for, :turntable
+      end
+
+      def records_for_with_turntable(ids)
+        returning_scope = records_for_without_turntable(ids)
+        if should_use_shard_key?
+          returning_scope = returning_scope.where(klass.turntable_shard_key => owners.map(&foreign_shard_key.to_sym).uniq)
+        end
+        returning_scope
+      end
+
+      private
+
+      def foreign_shard_key
+        options[:foreign_shard_key] || model.turntable_shard_key
+      end
+
+      def should_use_shard_key?
+        sharded_by_same_key? || !!options[:foreign_shard_key]
+      end
+
+      def sharded_by_same_key?
+        model.turntable_enabled? &&
+          klass.turntable_enabled? &&
+          model.turntable_shard_key == klass.turntable_shard_key
+      end
+    end
+  end
+end

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

@@ -3,88 +3,45 @@ module ActiveRecord::Turntable::ActiveRecordExt
     extend ActiveSupport::Concern
 
     included do
-      ActiveRecord::VERSION::STRING < '3.1' ?
-        include(AR30):
-        include(AR31)
-
       class << ActiveRecord::Base
-        delegate :clever_load!, :to => :scoped
+        delegate :clever_load!, :to => :all
       end
     end
 
-    module AR30
-      def clever_load!(association_name)
-        # load records
-        records = self.to_a
-        klass = records.first.class
-        reflection = klass.reflections[association_name]
-
-        if reflection
-          foreign_class = reflection.klass
-          foreign_objects = case reflection.macro
-                            when :has_one
-                              foreign_class.where(reflection.primary_key_name => records.map(&reflection.association_primary_key.to_sym).uniq)
-                            when :belongs_to
-                              foreign_class.where(reflection.association_primary_key => records.map(&reflection.primary_key_name.to_sym).uniq)
-                            else
-                              []
-                            end
-
-          self.each do |obj|
-            matched_object = case reflection.macro
-                             when :has_one
-                               foreign_objects.find {|fo|
-                                 obj.send(reflection.association_primary_key) == fo.send(reflection.primary_key_name)
-                               }
-                             when :belongs_to
-                               foreign_objects.find {|fo|
-                                 obj.send(reflection.primary_key_name) == fo.send(reflection.association_primary_key)
-                               }
-                             end
-            association_proxy = obj.send("set_#{reflection.name}_target", matched_object)
-            # TODO: set reverse_instance
-            # association_proxy.send(:set_inverse_instance, matched_object, obj)
-          end
-        end
-        records
-      end
-    end
-
-    module AR31
-      def clever_load!(association_name)
-        # load records
-        records = self.to_a
-        klass = records.first.class
-        reflection = klass.reflections[association_name]
-
-        if reflection
-          foreign_class = reflection.klass
-          foreign_objects = case reflection.macro
-                            when :has_one
-                              foreign_class.where(reflection.foreign_key => records.map(&reflection.association_primary_key.to_sym).uniq)
-                            when :belongs_to
-                              foreign_class.where(reflection.association_primary_key => records.map(&reflection.foreign_key.to_sym).uniq)
-                            else
-                              []
-                            end
-
-          self.each do |obj|
-            matched_object = case reflection.macro
-                             when :has_one
-                               foreign_objects.find {|fo|
-                                 obj.send(reflection.association_primary_key) == fo.send(reflection.foreign_key)
-                               }
-                             when :belongs_to
-                               foreign_objects.find {|fo|
-                                 obj.send(reflection.foreign_key) == fo.send(reflection.association_primary_key)
-                               }
-                             end
-            obj.association(association_name).target = matched_object
-            obj.association(association_name).send(:set_inverse_instance, matched_object)
-          end
+    def clever_load!(association_name)
+      # load records
+      records = self.to_a
+      klass = records.first.class
+      reflection = klass.reflections[association_name]
+
+      if reflection
+        foreign_class = reflection.klass
+        foreign_objects = case reflection.macro
+                          when :has_one
+                            foreign_class.where(reflection.foreign_key => records.map(&reflection.association_primary_key.to_sym).uniq)
+                          when :belongs_to
+                            foreign_class.where(reflection.association_primary_key => records.map(&reflection.foreign_key.to_sym).uniq)
+                          else
+                            []
+                          end
+
+        self.each do |obj|
+          matched_object = case reflection.macro
+                           when :has_one
+                             foreign_objects.find {|fo|
+                               obj.send(reflection.association_primary_key) == fo.send(reflection.foreign_key)
+                             }
+                           when :belongs_to
+                             foreign_objects.find {|fo|
+                               obj.send(reflection.foreign_key) == fo.send(reflection.association_primary_key)
+                             }
+                           end
+          obj.association(association_name).target = matched_object
+          obj.association(association_name).set_inverse_instance(matched_object) if matched_object
+          obj.association(association_name).loaded!
         end
-        records
       end
+      records
     end
   end
 end

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

@@ -0,0 +1,31 @@
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module ConnectionHandlerExtension
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :pool_for, :turntable
+      end
+
+      private
+
+      def pool_for_with_turntable(owner)
+        owner_to_pool.fetch(owner.name) {
+          if ancestor_pool = pool_from_any_process_for(owner)
+            if ancestor_pool.is_a?(ActiveRecord::Turntable::PoolProxy)
+              # Use same PoolProxy object
+              owner_to_pool[owner.name] = ancestor_pool
+            else
+              # 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 owner, ancestor_pool.spec
+            end
+          else
+            owner_to_pool[owner.name] = nil
+          end
+        }
+      end
+    end
+  end
+end