activerecord-turntable 2.5.0 → 3.0.0.alpha1

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

@@ -6,10 +6,9 @@ module ActiveRecord::Turntable
       ::ActiveRecord::Persistence.class_eval do
         # @note Override to add sharding scope on reloading
         def reload(options = nil)
-          clear_aggregation_cache
-          clear_association_cache
+          self.class.connection.clear_query_cache
 
-          finder_scope = if turntable_enabled? and self.class.primary_key != self.class.turntable_shard_key.to_s
+          finder_scope = if turntable_enabled? && self.class.primary_key != self.class.turntable_shard_key.to_s
                            self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
                          else
                            self.class.unscoped
@@ -17,88 +16,56 @@ module ActiveRecord::Turntable
 
           fresh_object =
             if options && options[:lock]
-              finder_scope.lock.find(id)
+              finder_scope.lock(options[:lock]).find(id)
             else
               finder_scope.find(id)
             end
 
-          if Util.ar42_or_later?
-            @attributes = fresh_object.instance_variable_get('@attributes')
-          else
-            @attributes.update(fresh_object.instance_variable_get('@attributes'))
-
-            @column_types           = self.class.column_types
-            @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
-            @attributes_cache       = {}
-          end
+          @attributes = fresh_object.instance_variable_get("@attributes")
           @new_record = false
           self
         end
 
         # @note Override to add sharding scope on `touch`
-        if Util.ar42_or_later?
-          def touch(*names)
-            raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
-
-            attributes = timestamp_attributes_for_update_in_model
-            attributes.concat(names)
-
-            unless attributes.empty?
-              current_time = current_time_from_proper_timezone
-              changes = {}
-
-              attributes.each do |column|
-                column = column.to_s
-                changes[column] = write_attribute(column, current_time)
-              end
-
-              changes[self.class.locking_column] = increment_lock if locking_enabled?
+        def touch(*names, time: nil)
+          raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
 
-              clear_attribute_changes(changes.keys)
-              primary_key = self.class.primary_key
+          time ||= current_time_from_proper_timezone
+          attributes = timestamp_attributes_for_update_in_model
+          attributes.concat(names)
 
-              finder_scope = if turntable_enabled? and primary_key != self.class.turntable_shard_key.to_s
-                               self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
-                             else
-                               self.class.unscoped
-                             end
+          unless attributes.empty?
+            changes = {}
 
-              finder_scope.where(primary_key => self[primary_key]).update_all(changes) == 1
-            else
-              true
+            attributes.each do |column|
+              column = column.to_s
+              changes[column] = write_attribute(column, time)
             end
-          end
-        else
-          def touch(name = nil)
-            raise ActiveRecordError, "can not touch on a new record object" unless persisted?
-
-            attributes = timestamp_attributes_for_update_in_model
-            attributes << name if name
-
-            unless attributes.empty?
-              current_time = current_time_from_proper_timezone
-              changes = {}
-
-              attributes.each do |column|
-                column = column.to_s
-                changes[column] = write_attribute(column, current_time)
-              end
-
-              changes[self.class.locking_column] = increment_lock if locking_enabled?
 
-              @changed_attributes.except!(*changes.keys)
-              primary_key = self.class.primary_key
+            clear_attribute_changes(changes.keys)
+            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))
+                    else
+                      self.class.unscoped
+                    end
+            scope = scope.where(primary_key => _read_attribute(primary_key))
+
+            if locking_enabled?
+              locking_column = self.class.locking_column
+              scope = scope.where(locking_column => _read_attribute(locking_column))
+              changes[locking_column] = increment_lock
+            end
 
-              finder_scope = if turntable_enabled? and primary_key != self.class.turntable_shard_key.to_s
-                               self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
-                             else
-                               self.class.unscoped
-                             end
+            result = scope.update_all(changes) == 1
 
-              finder_scope.where(primary_key => self[primary_key]).update_all(changes) == 1
-            else
-              true
+            if !result && locking_enabled?
+              raise ActiveRecord::StaleObjectError.new(self, "touch")
             end
+
+            result
+          else
+            true
           end
         end
 
@@ -111,7 +78,7 @@ module ActiveRecord::Turntable
             verify_readonly_attribute(key.to_s)
           end
 
-          update_scope = if turntable_enabled? and self.class.primary_key != self.class.turntable_shard_key.to_s
+          update_scope = if turntable_enabled? && self.class.primary_key != self.class.turntable_shard_key.to_s
                            self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
                          else
                            self.class.unscoped
@@ -129,89 +96,28 @@ module ActiveRecord::Turntable
         private
 
         # @note Override to add sharding scope on destroying
-        if Util.ar42_or_later?
-          def relation_for_destroy
-            pk         = self.class.primary_key
-            column     = self.class.columns_hash[pk]
-            substitute = self.class.connection.substitute_at(column, 0)
-            klass      = self.class
-
-            relation = self.class.unscoped.where(
-                                                 self.class.arel_table[pk].eq(substitute))
-            relation.bind_values = [[column, id]]
-
-            if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-              shard_key_column = klass.columns_hash[klass.turntable_shard_key]
-              shard_key_substitute = klass.connection.substitute_at(shard_key_column)
-
-              relation = relation.where(self.class.arel_table[klass.turntable_shard_key].eq(shard_key_substitute))
-              relation.bind_values << [shard_key_column, self[klass.turntable_shard_key]]
-            end
-            relation
-          end
-        else
-          def relation_for_destroy
-            pk         = self.class.primary_key
-            column     = self.class.columns_hash[pk]
-            substitute = self.class.connection.substitute_at(column, 0)
-            klass      = self.class
-
-            relation = self.class.unscoped.where(
-                                                 self.class.arel_table[pk].eq(substitute))
-            if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-              relation = relation.where(klass.turntable_shard_key => self.send(turntable_shard_key))
-            end
-            relation.bind_values = [[column, id]]
-            relation
+        def relation_for_destroy
+          klass = self.class
+          relation = klass.unscoped.where(klass.primary_key => id)
+
+          if klass.turntable_enabled? && klass.primary_key != klass.turntable_shard_key.to_s
+            relation = relation.where(klass.turntable_shard_key => self[klass.turntable_shard_key])
           end
+          relation
         end
 
         # @note Override to add sharding scope on updating
-        if Util.earlier_than_ar41?
-          method_name = Util.ar_version_earlier_than?("4.0.6") ? "update_record" : "_update_record"
-          class_eval <<-EOD
-            def #{method_name}(attribute_names = @attributes.keys)
-              attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
-              if attributes_with_values.empty?
-                0
-              else
-                klass = self.class
-                column_hash = klass.connection.schema_cache.columns_hash klass.table_name
-                db_columns_with_values = attributes_with_values.map { |attr,value|
-                  real_column = column_hash[attr.name]
-                  [real_column, value]
-                }
-                bind_attrs = attributes_with_values.dup
-                bind_attrs.keys.each_with_index do |column, i|
-                  real_column = db_columns_with_values[i].first
-                  bind_attrs[column] = klass.connection.substitute_at(real_column, i)
-                end
-                condition_scope = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id_was || id))
-                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(turntable_shard_key))
-                end
-                stmt = condition_scope.arel.compile_update(bind_attrs)
-                klass.connection.update stmt, 'SQL', db_columns_with_values
-              end
-            end
-          EOD
-        else
-          method_name = Util.ar_version_earlier_than?("4.1.2") ? "update_record" : "_update_record"
-          attributes_method_name = Util.ar42_or_later? ? "self.attribute_names" : "@attributes.keys"
-          class_eval <<-EOD
-            def #{method_name}(attribute_names = #{attributes_method_name})
-              klass = self.class
-              attributes_values = arel_attributes_with_values_for_update(attribute_names)
-              if attributes_values.empty?
-                0
-              else
-                scope = if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-                  klass.unscoped.where(klass.turntable_shard_key => self.send(turntable_shard_key))
-                end
-                klass.unscoped.#{method_name} attributes_values, id, id_was, scope
-              end
-            end
-          EOD
+        def _update_record(attribute_names = self.attribute_names)
+          klass = self.class
+          attributes_values = arel_attributes_with_values_for_update(attribute_names)
+          if attributes_values.empty?
+            0
+          else
+            scope = if klass.turntable_enabled? and 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
+          end
         end
       end
     end

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

@@ -1,56 +1,28 @@
 module ActiveRecord::Turntable
   module ActiveRecordExt
     module Relation
-      extend ActiveSupport::Concern
-
-      included do
-        if Util.ar41_or_later?
-          if Util.ar_version_earlier_than?('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
-
       # @note Override to add sharding scope on updating
-      if Util.ar42_or_later?
-        def _update_record_with_turntable(values, id, id_was, turntable_scope = nil) # :nodoc:
-          substitutes, binds = substitute_values values
+      def _update_record(values, id, id_was, turntable_scope = nil) # :nodoc:
+        substitutes, binds = substitute_values values
 
-          scope = @klass.unscoped
+        scope = @klass.unscoped
 
-          if @klass.finder_needs_type_condition?
-            scope.unscope!(where: @klass.inheritance_column)
-          end
-
-          relation = scope.where(@klass.primary_key => (id_was || id))
-          relation = relation.merge(turntable_scope) if turntable_scope
-
-          bvs = binds + relation.bind_values
-          um = relation
-            .arel
-            .compile_update(substitutes, @klass.primary_key)
-
-          @klass.connection.update(
-            um,
-            'SQL',
-            bvs,
-          )
+        if @klass.finder_needs_type_condition?
+          scope.unscope!(where: @klass.inheritance_column)
         end
-      else
-        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
+        relation = scope.where(@klass.primary_key => (id_was || id))
+        relation = relation.merge(turntable_scope) if turntable_scope
+        bvs = binds + relation.bound_attributes
+        um = relation.
+             arel.
+             compile_update(substitutes, @klass.primary_key)
+
+        @klass.connection.update(
+          um,
+          "SQL",
+          bvs
+        )
       end
     end
   end

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

@@ -2,103 +2,105 @@
 module ActiveRecord::Turntable
   module ActiveRecordExt
     module SchemaDumper
-      extend ActiveSupport::Concern
-
-      included do
-        alias_method_chain :table, :turntable
-      end
 
       private
 
-      # @note Override to dump database sequencer method
-      def table_with_turntable(table, stream)
-        columns = @connection.columns(table)
-        begin
-          tbl = StringIO.new
-
-          # first dump primary key column
-          if @connection.respond_to?(:pk_and_sequence_for)
-            pk, _ = @connection.pk_and_sequence_for(table)
-          elsif @connection.respond_to?(:primary_key)
-            pk = @connection.primary_key(table)
-          end
+        # @note Override to dump database sequencer method
+        def table(table, stream)
+          columns = @connection.columns(table)
+          begin
+            tbl = StringIO.new
+
+            # first dump primary key column
+            if @connection.respond_to?(:primary_keys)
+              pk = @connection.primary_keys(table)
+              pk = pk.first unless pk.size > 1
+            else
+              pk = @connection.primary_key(table)
+            end
 
-          if table =~ /\A(.*)_id_seq\z/
-            tbl.print "  create_sequence_for #{remove_prefix_and_suffix($1).inspect}"
-          else
-            tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
-          end
-          pkcol = columns.detect { |c| c.name == pk }
-          if pkcol
-            if pk != 'id'
-              tbl.print %Q(, primary_key: "#{pk}")
-            elsif pkcol.sql_type == 'bigint'
-              tbl.print ", id: :bigserial"
-            elsif pkcol.sql_type == 'uuid'
-              tbl.print ", id: :uuid"
-              tbl.print %Q(, default: "#{pkcol.default_function.inspect}")
+            if table =~ /\A(.*)_id_seq\z/
+              tbl.print "  create_sequence_for #{remove_prefix_and_suffix(Regexp.last_match(1)).inspect}"
+            else
+              tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+            end
+
+            case pk
+            when String
+              tbl.print ", primary_key: #{pk.inspect}" unless pk == 'id'
+              pkcol = columns.detect { |c| c.name == pk }
+              pkcolspec = @connection.column_spec_for_primary_key(pkcol)
+              if pkcolspec.present?
+                pkcolspec.each do |key, value|
+                  tbl.print ", #{key}: #{value}"
+                end
+              end
+            when Array
+              tbl.print ", primary_key: #{pk.inspect}"
+            else
+              tbl.print ", id: false"
             end
-          else
-            tbl.print ", id: false"
-          end
-          if Util.earlier_than_ar42?
-            tbl.print ", force: true"
-          else
             tbl.print ", force: :cascade"
-          end
-          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}'" unless @connection.valid_type?(column.type)
-            next if column.name == pk
-            @connection.column_spec(column, @types)
-          end.compact
+            table_options = @connection.table_options(table)
+            tbl.print ", options: #{table_options.inspect}" unless table_options.blank?
+
+            if comment = @connection.table_comment(table).presence
+              tbl.print ", comment: #{comment.inspect}"
+            end
 
-          # find all migration keys used in this table
-          keys = @connection.migration_keys
+            tbl.puts " do |t|"
 
-          # 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
-          }
+            # then dump all non-primary key columns
+            column_specs = columns.map do |column|
+              raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
+              next if column.name == pk
+              @connection.column_spec(column)
+            end.compact
 
-          # the string we're going to sprintf our values against, with standardized column widths
-          format_string = lengths.map{ |len| "%-#{len}s" }
+            # find all migration keys used in this table
+            keys = @connection.migration_keys
 
-          # find the max length for the 'type' column, which is special
-          type_length = column_specs.map{ |column| column[:type].length }.max
+            # 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
+            }
 
-          # add column type definition to our format string
-          format_string.unshift "    t.%-#{type_length}s "
+            # the string we're going to sprintf our values against, with standardized column widths
+            format_string = lengths.map{ |len| "%-#{len}s" }
 
-          format_string *= ''
+            # find the max length for the 'type' column, which is special
+            type_length = column_specs.map{ |column| column[:type].length }.max
 
-          column_specs.each do |colspec|
-            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
-            values.unshift colspec[:type]
-            tbl.print((format_string % values).gsub(/,\s*$/, ''))
-            tbl.puts
-          end
+            # add column type definition to our format string
+            format_string.unshift "    t.%-#{type_length}s "
 
-          tbl.puts "  end"
-          tbl.puts
+            format_string *= ''
 
-          indexes(table, tbl)
+            column_specs.each do |colspec|
+              values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+              values.unshift colspec[:type]
+              tbl.print((format_string % values).gsub(/,\s*$/, ''))
+              tbl.puts
+            end
 
-          tbl.rewind
-          stream.print tbl.read
-        rescue => e
-          stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
-          stream.puts "#   #{e.message}"
-          stream.puts
-        end
+            indexes_in_create(table, tbl)
 
-        stream
-      end
+            tbl.puts "  end"
+            tbl.puts
+
+            tbl.rewind
+            stream.print tbl.read
+          rescue => e
+            stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+            stream.puts "#   #{e.message}"
+            stream.puts
+          end
 
+          stream
+        end
     end
   end
 end

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

@@ -1,23 +1,14 @@
 module ActiveRecord::Turntable::ActiveRecordExt
   module Sequencer
-    extend ActiveSupport::Concern
-
-    included do
-      include DatabaseStatements
-      alias_method_chain :prefetch_primary_key?, :turntable
-    end
-
-    module DatabaseStatements
-      def default_sequence_name(table_name, pk = nil)
-        if ActiveRecord::Turntable::Sequencer.has_sequencer?(table_name)
-          ActiveRecord::Turntable::Sequencer.sequence_name(table_name, pk)
-        else
-          super
-        end
+    def default_sequence_name(table_name, pk = nil)
+      if ActiveRecord::Turntable::Sequencer.has_sequencer?(table_name)
+        ActiveRecord::Turntable::Sequencer.sequence_name(table_name, pk)
+      else
+        super
       end
     end
 
-    def prefetch_primary_key_with_turntable?(table_name = nil)
+    def prefetch_primary_key?(table_name = nil)
       ActiveRecord::Turntable::Sequencer.has_sequencer?(table_name)
     end
 

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

@@ -5,8 +5,8 @@ module ActiveRecord::Turntable
       def with_transaction_returning_status
         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 self.class.connection.prefetch_primary_key?(self.class.table_name)
+          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
@@ -14,11 +14,7 @@ module ActiveRecord::Turntable
             begin
               status = yield
             rescue ActiveRecord::Rollback
-              if Util.ar42_or_later?
-                clear_transaction_record_state
-              else
-                @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-              end
+              clear_transaction_record_state
               status = nil
             end
 
@@ -28,13 +24,22 @@ module ActiveRecord::Turntable
         else
           super
         end
+
+      ensure
+        if @transaction_state && @transaction_state.committed?
+          clear_transaction_record_state
+        end
       end
 
       def add_to_transaction
         if self.class.turntable_enabled?
-          if self.turntable_shard.connection.add_transaction_record(self)
-            remember_transaction_record_state
+          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
         else
           super
         end

data/lib/active_record/turntable/active_record_ext.rb

@@ -20,22 +20,21 @@ module ActiveRecord::Turntable
 
     included do
       include Transactions
-      ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, Sequencer)
-      ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, AbstractAdapter)
-      ActiveRecord::LogSubscriber.send(:include, LogSubscriber)
-      ActiveRecord::Persistence.send(:include, Persistence)
-      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(:prepend, 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'
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(Sequencer)
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(AbstractAdapter)
+      ActiveRecord::LogSubscriber.prepend(LogSubscriber)
+      ActiveRecord::Persistence.include(Persistence)
+      ActiveRecord::Locking::Optimistic.include(LockingOptimistic)
+      ActiveRecord::Relation.include(CleverLoad)
+      ActiveRecord::Relation.prepend(Relation)
+      ActiveRecord::Migration.include(ActiveRecord::Turntable::Migration)
+      ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ConnectionHandlerExtension)
+      ActiveRecord::Associations::Preloader::Association.prepend(AssociationPreloader)
+      ActiveRecord::Associations::Association.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/modulo_algorithm.rb

@@ -6,7 +6,7 @@ module ActiveRecord::Turntable::Algorithm
     end
 
     def calculate(key)
-      @config["shards"][key % @config["shards"].size]["connection"]
+      @config[:shards][key % @config[:shards].size][:connection]
     rescue
       raise ActiveRecord::Turntable::CannotSpecifyShardError, "cannot specify shard for key:#{key}"
     end