activerecord 6.0.0.beta2 → 6.0.2.rc1

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -3,6 +3,8 @@
 module ActiveRecord
   module Tasks # :nodoc:
     class MySQLDatabaseTasks # :nodoc:
+      ER_DB_CREATE_EXISTS = 1007
+
       delegate :connection, :establish_connection, to: ActiveRecord::Base
 
       def initialize(configuration)
@@ -14,7 +16,7 @@ module ActiveRecord
         connection.create_database configuration["database"], creation_options
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => error
-        if error.message.include?("database exists")
+        if connection.error_number(error.cause) == ER_DB_CREATE_EXISTS
           raise DatabaseAlreadyExists
         else
           raise

data/lib/active_record/test_databases.rb

@@ -8,31 +8,16 @@ module ActiveRecord
       create_and_load_schema(i, env_name: Rails.env)
     end
 
-    ActiveSupport::Testing::Parallelization.run_cleanup_hook do
-      drop(env_name: Rails.env)
-    end
-
     def self.create_and_load_schema(i, env_name:)
       old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
 
       ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
         db_config.config["database"] += "-#{i}"
-        ActiveRecord::Tasks::DatabaseTasks.create(db_config.config)
-        ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config.config, ActiveRecord::Base.schema_format, nil, env_name, db_config.spec_name)
+        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config.config, ActiveRecord::Base.schema_format, nil, env_name, db_config.spec_name)
       end
     ensure
       ActiveRecord::Base.establish_connection(Rails.env.to_sym)
       ENV["VERBOSE"] = old
     end
-
-    def self.drop(env_name:)
-      old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
-
-      ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
-        ActiveRecord::Tasks::DatabaseTasks.drop(db_config.config)
-      end
-    ensure
-      ENV["VERBOSE"] = old
-    end
   end
 end

data/lib/active_record/test_fixtures.rb

@@ -129,6 +129,7 @@ module ActiveRecord
         # When connections are established in the future, begin a transaction too
         @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
           spec_name = payload[:spec_name] if payload.key?(:spec_name)
+          setup_shared_connection_pool
 
           if spec_name
             begin

data/lib/active_record/timestamp.rb

@@ -59,19 +59,26 @@ module ActiveRecord
         attribute_names.index_with(time || current_time_from_proper_timezone)
       end
 
-      private
-        def timestamp_attributes_for_create_in_model
-          timestamp_attributes_for_create.select { |c| column_names.include?(c) }
-        end
+      def timestamp_attributes_for_create_in_model
+        @timestamp_attributes_for_create_in_model ||=
+          (timestamp_attributes_for_create & column_names).freeze
+      end
 
-        def timestamp_attributes_for_update_in_model
-          timestamp_attributes_for_update.select { |c| column_names.include?(c) }
-        end
+      def timestamp_attributes_for_update_in_model
+        @timestamp_attributes_for_update_in_model ||=
+          (timestamp_attributes_for_update & column_names).freeze
+      end
 
-        def all_timestamp_attributes_in_model
-          timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
-        end
+      def all_timestamp_attributes_in_model
+        @all_timestamp_attributes_in_model ||=
+          (timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model).freeze
+      end
 
+      def current_time_from_proper_timezone
+        default_timezone == :utc ? Time.now.utc : Time.now
+      end
+
+      private
         def timestamp_attributes_for_create
           ["created_at", "created_on"]
         end
@@ -80,8 +87,11 @@ module ActiveRecord
           ["updated_at", "updated_on"]
         end
 
-        def current_time_from_proper_timezone
-          default_timezone == :utc ? Time.now.utc : Time.now
+        def reload_schema_from_cache
+          @timestamp_attributes_for_create_in_model = nil
+          @timestamp_attributes_for_update_in_model = nil
+          @all_timestamp_attributes_in_model = nil
+          super
         end
     end
 
@@ -124,19 +134,19 @@ module ActiveRecord
     end
 
     def timestamp_attributes_for_create_in_model
-      self.class.send(:timestamp_attributes_for_create_in_model)
+      self.class.timestamp_attributes_for_create_in_model
     end
 
     def timestamp_attributes_for_update_in_model
-      self.class.send(:timestamp_attributes_for_update_in_model)
+      self.class.timestamp_attributes_for_update_in_model
     end
 
     def all_timestamp_attributes_in_model
-      self.class.send(:all_timestamp_attributes_in_model)
+      self.class.all_timestamp_attributes_in_model
     end
 
     def current_time_from_proper_timezone
-      self.class.send(:current_time_from_proper_timezone)
+      self.class.current_time_from_proper_timezone
     end
 
     def max_updated_column_timestamp

data/lib/active_record/touch_later.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   # = Active Record Touch Later
-  module TouchLater
+  module TouchLater # :nodoc:
     extend ActiveSupport::Concern
 
     included do
@@ -22,7 +22,8 @@ module ActiveRecord
       @_touch_time = current_time_from_proper_timezone
 
       surreptitiously_touch @_defer_touch_attrs
-      self.class.connection.add_transaction_record self
+      add_to_transaction
+      @_new_record_before_last_commit ||= false
 
       # touch the parents as we are not calling the after_save callbacks
       self.class.reflect_on_all_associations(:belongs_to).each do |r|
@@ -48,6 +49,7 @@ module ActiveRecord
 
       def touch_deferred_attributes
         if has_defer_touch_attrs? && persisted?
+          @_skip_dirty_tracking = true
           touch(*@_defer_touch_attrs, time: @_touch_time)
           @_defer_touch_attrs, @_touch_time = nil, nil
         end

data/lib/active_record/transactions.rb

@@ -234,6 +234,12 @@ module ActiveRecord
         set_callback(:commit, :after, *args, &block)
       end
 
+      # Shortcut for <tt>after_commit :hook, on: [ :create, :update ]</tt>.
+      def after_save_commit(*args, &block)
+        set_options_for_callbacks!(args, on: [ :create, :update ])
+        set_callback(:commit, :after, *args, &block)
+      end
+
       # Shortcut for <tt>after_commit :hook, on: :create</tt>.
       def after_create_commit(*args, &block)
         set_options_for_callbacks!(args, on: :create)
@@ -327,14 +333,14 @@ module ActiveRecord
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
     def committed!(should_run_callbacks: true) #:nodoc:
-      if should_run_callbacks && (destroyed? || persisted?)
+      force_clear_transaction_record_state
+      if should_run_callbacks
         @_committed_already_called = true
         _run_commit_without_transaction_enrollment_callbacks
         _run_commit_callbacks
       end
     ensure
       @_committed_already_called = false
-      force_clear_transaction_record_state
     end
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record
@@ -349,18 +355,6 @@ module ActiveRecord
       clear_transaction_record_state
     end
 
-    # Add the record to the current transaction so that the #after_rollback and #after_commit callbacks
-    # can be called.
-    def add_to_transaction
-      if has_transactional_callbacks?
-        self.class.connection.add_transaction_record(self)
-      else
-        sync_with_transaction_state
-        set_transaction_state(self.class.connection.transaction_state)
-      end
-      remember_transaction_record_state
-    end
-
     # Executes +method+ within a transaction and captures its return value as a
     # status flag. If the status is true the transaction is committed, otherwise
     # a ROLLBACK is issued. In any case the status flag is returned.
@@ -370,29 +364,40 @@ module ActiveRecord
     def with_transaction_returning_status
       status = nil
       self.class.transaction do
-        add_to_transaction
+        if has_transactional_callbacks?
+          add_to_transaction
+        else
+          sync_with_transaction_state if @transaction_state&.finalized?
+          @transaction_state = self.class.connection.transaction_state
+        end
+        remember_transaction_record_state
+
         status = yield
         raise ActiveRecord::Rollback unless status
       end
       status
     end
 
+    def trigger_transactional_callbacks? # :nodoc:
+      (@_new_record_before_last_commit || _trigger_update_callback) && persisted? ||
+        _trigger_destroy_callback && destroyed?
+    end
+
     private
       attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
 
       # Save the new record state and id of a record so it can be restored later if a transaction fails.
       def remember_transaction_record_state
-        @_start_transaction_state.reverse_merge!(
+        @_start_transaction_state ||= {
           id: id,
           new_record: @new_record,
           destroyed: @destroyed,
+          attributes: @attributes,
           frozen?: frozen?,
-        )
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
-        remember_new_record_before_last_commit
-      end
+          level: 0
+        }
+        @_start_transaction_state[:level] += 1
 
-      def remember_new_record_before_last_commit
         if _committed_already_called
           @_new_record_before_last_commit = false
         else
@@ -402,27 +407,32 @@ module ActiveRecord
 
       # Clear the new record state and id of a record.
       def clear_transaction_record_state
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+        return unless @_start_transaction_state
+        @_start_transaction_state[:level] -= 1
         force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
       end
 
       # Force to clear the transaction record state.
       def force_clear_transaction_record_state
-        @_start_transaction_state.clear
+        @_start_transaction_state = nil
+        @transaction_state = nil
       end
 
       # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
-      def restore_transaction_record_state(force = false)
-        unless @_start_transaction_state.empty?
-          transaction_level = (@_start_transaction_state[:level] || 0) - 1
-          if transaction_level < 1 || force
-            restore_state = @_start_transaction_state
-            thaw
+      def restore_transaction_record_state(force_restore_state = false)
+        if restore_state = @_start_transaction_state
+          if force_restore_state || restore_state[:level] <= 1
             @new_record = restore_state[:new_record]
             @destroyed  = restore_state[:destroyed]
-            pk = self.class.primary_key
-            if pk && _read_attribute(pk) != restore_state[:id]
-              _write_attribute(pk, restore_state[:id])
+            @attributes = restore_state[:attributes].map do |attr|
+              value = @attributes.fetch_value(attr.name)
+              attr = attr.with_value_from_user(value) if attr.value != value
+              attr
+            end
+            @mutations_from_database = nil
+            @mutations_before_last_save = nil
+            if @attributes.fetch_value(@primary_key) != restore_state[:id]
+              @attributes.write_from_user(@primary_key, restore_state[:id])
             end
             freeze if restore_state[:frozen?]
           end
@@ -443,8 +453,10 @@ module ActiveRecord
         end
       end
 
-      def set_transaction_state(state)
-        @transaction_state = state
+      # Add the record to the current transaction so that the #after_rollback and #after_commit
+      # callbacks can be called.
+      def add_to_transaction
+        self.class.connection.add_transaction_record(self)
       end
 
       def has_transactional_callbacks?
@@ -464,19 +476,17 @@ module ActiveRecord
       # This method checks to see if the ActiveRecord object's state reflects
       # the TransactionState, and rolls back or commits the Active Record object
       # as appropriate.
-      #
-      # Since Active Record objects can be inside multiple transactions, this
-      # method recursively goes through the parent of the TransactionState and
-      # checks if the Active Record object reflects the state of the object.
       def sync_with_transaction_state
-        update_attributes_from_transaction_state(@transaction_state)
-      end
-
-      def update_attributes_from_transaction_state(transaction_state)
-        if transaction_state && transaction_state.finalized?
-          restore_transaction_record_state(transaction_state.fully_rolledback?) if transaction_state.rolledback?
-          force_clear_transaction_record_state if transaction_state.fully_committed?
-          clear_transaction_record_state if transaction_state.fully_completed?
+        if transaction_state = @transaction_state
+          if transaction_state.fully_committed?
+            force_clear_transaction_record_state
+          elsif transaction_state.committed?
+            clear_transaction_record_state
+          elsif transaction_state.rolledback?
+            force_restore_state = transaction_state.fully_rolledback?
+            restore_transaction_record_state(force_restore_state)
+            clear_transaction_record_state
+          end
         end
       end
   end

data/lib/active_record/type_caster/connection.rb

@@ -8,21 +8,27 @@ module ActiveRecord
         @table_name = table_name
       end
 
-      def type_cast_for_database(attribute_name, value)
+      def type_cast_for_database(attr_name, value)
         return value if value.is_a?(Arel::Nodes::BindParam)
-        column = column_for(attribute_name)
-        connection.type_cast_from_column(column, value)
+        type = type_for_attribute(attr_name)
+        type.serialize(value)
       end
 
-      private
-        attr_reader :table_name
-        delegate :connection, to: :@klass
+      def type_for_attribute(attr_name)
+        schema_cache = connection.schema_cache
 
-        def column_for(attribute_name)
-          if connection.schema_cache.data_source_exists?(table_name)
-            connection.schema_cache.columns_hash(table_name)[attribute_name.to_s]
-          end
+        if schema_cache.data_source_exists?(table_name)
+          column = schema_cache.columns_hash(table_name)[attr_name.to_s]
+          type = connection.lookup_cast_type_from_column(column) if column
         end
+
+        type || Type.default_value
+      end
+
+      delegate :connection, to: :@klass, private: true
+
+      private
+        attr_reader :table_name
     end
   end
 end

data/lib/active_record/validations.rb

@@ -40,6 +40,7 @@ module ActiveRecord
     include ActiveModel::Validations
 
     # The validation process on save can be skipped by passing <tt>validate: false</tt>.
+    # The validation context can be changed by passing <tt>context: context</tt>.
     # The regular {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] method is replaced
     # with this when the validations module is mixed in, which it is by default.
     def save(options = {})

data/lib/active_record/validations/uniqueness.rb

@@ -25,7 +25,7 @@ module ActiveRecord
           if finder_class.primary_key
             relation = relation.where.not(finder_class.primary_key => record.id_in_database)
           else
-            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
+            raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
           end
         end
         relation = scope_relation(record, relation)
@@ -60,10 +60,8 @@ module ActiveRecord
         comparison = relation.bind_attribute(attribute, value) do |attr, bind|
           return relation.none! if bind.unboundable?
 
-          if bind.nil?
-            attr.eq(bind)
-          elsif !options.key?(:case_sensitive)
-            klass.connection.default_uniqueness_comparison(attr, bind)
+          if !options.key?(:case_sensitive) || bind.nil?
+            klass.connection.default_uniqueness_comparison(attr, bind, klass)
           elsif options[:case_sensitive]
             klass.connection.case_sensitive_comparison(attr, bind)
           else

data/lib/arel.rb

@@ -24,22 +24,29 @@ require "arel/update_manager"
 require "arel/delete_manager"
 require "arel/nodes"
 
-module Arel # :nodoc: all
+module Arel
   VERSION = "10.0.0"
 
+  # Wrap a known-safe SQL string for passing to query methods, e.g.
+  #
+  #   Post.order(Arel.sql("length(title)")).last
+  #
+  # Great caution should be taken to avoid SQL injection vulnerabilities.
+  # This method should not be used with unsafe values such as request
+  # parameters or model attributes.
   def self.sql(raw_sql)
     Arel::Nodes::SqlLiteral.new raw_sql
   end
 
-  def self.star
+  def self.star # :nodoc:
     sql "*"
   end
 
-  def self.arel_node?(value)
+  def self.arel_node?(value) # :nodoc:
     value.is_a?(Arel::Node) || value.is_a?(Arel::Attribute) || value.is_a?(Arel::Nodes::SqlLiteral)
   end
 
-  def self.fetch_attribute(value)
+  def self.fetch_attribute(value) # :nodoc:
     case value
     when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
       yield value.left.is_a?(Arel::Attributes::Attribute) ? value.left : value.right
@@ -47,5 +54,5 @@ module Arel # :nodoc: all
   end
 
   ## Convenience Alias
-  Node = Arel::Nodes::Node
+  Node = Arel::Nodes::Node # :nodoc:
 end