activerecord 6.0.5.1 → 6.1.7.4

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -12,26 +12,24 @@ module ActiveRecord
       delegate :connection, :establish_connection, :clear_active_connections!,
         to: ActiveRecord::Base
 
-      def initialize(configuration)
-        @configuration = configuration
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
       end
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration["database"],
-          configuration.merge("encoding" => encoding)
-        establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if error.cause.is_a?(PG::DuplicateDatabase)
-          raise DatabaseAlreadyExists
-        else
-          raise
-        end
+        connection.create_database(db_config.database, configuration_hash.merge(encoding: encoding))
+        establish_connection(db_config)
       end
 
       def drop
         establish_master_connection
-        connection.drop_database configuration["database"]
+        connection.drop_database(db_config.database)
       end
 
       def charset
@@ -54,14 +52,14 @@ module ActiveRecord
         search_path = \
           case ActiveRecord::Base.dump_schemas
           when :schema_search_path
-            configuration["schema_search_path"]
+            configuration_hash[:schema_search_path]
           when :all
             nil
           when String
             ActiveRecord::Base.dump_schemas
           end
 
-        args = ["-s", "-x", "-O", "-f", filename]
+        args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
         args.concat(Array(extra_flags)) if extra_flags
         unless search_path.blank?
           args += search_path.split(",").map do |part|
@@ -74,7 +72,7 @@ module ActiveRecord
           args += ignore_tables.flat_map { |table| ["-T", table] }
         end
 
-        args << configuration["database"]
+        args << db_config.database
         run_cmd("pg_dump", args, "dumping")
         remove_sql_header_comments(filename)
         File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
@@ -82,31 +80,31 @@ module ActiveRecord
 
       def structure_load(filename, extra_flags)
         set_psql_env
-        args = ["-v", ON_ERROR_STOP_1, "-q", "-X", "-f", filename]
+        args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--file", filename]
         args.concat(Array(extra_flags)) if extra_flags
-        args << configuration["database"]
+        args << db_config.database
         run_cmd("psql", args, "loading")
       end
 
       private
-        attr_reader :configuration
+        attr_reader :db_config, :configuration_hash
 
         def encoding
-          configuration["encoding"] || DEFAULT_ENCODING
+          configuration_hash[:encoding] || DEFAULT_ENCODING
         end
 
         def establish_master_connection
-          establish_connection configuration.merge(
-            "database"           => "postgres",
-            "schema_search_path" => "public"
+          establish_connection configuration_hash.merge(
+            database: "postgres",
+            schema_search_path: "public"
           )
         end
 
         def set_psql_env
-          ENV["PGHOST"]     = configuration["host"]          if configuration["host"]
-          ENV["PGPORT"]     = configuration["port"].to_s     if configuration["port"]
-          ENV["PGPASSWORD"] = configuration["password"].to_s if configuration["password"]
-          ENV["PGUSER"]     = configuration["username"].to_s if configuration["username"]
+          ENV["PGHOST"]     = db_config.host                     if db_config.host
+          ENV["PGPORT"]     = configuration_hash[:port].to_s     if configuration_hash[:port]
+          ENV["PGPASSWORD"] = configuration_hash[:password].to_s if configuration_hash[:password]
+          ENV["PGUSER"]     = configuration_hash[:username].to_s if configuration_hash[:username]
         end
 
         def run_cmd(cmd, args, action)

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -5,20 +5,25 @@ module ActiveRecord
     class SQLiteDatabaseTasks # :nodoc:
       delegate :connection, :establish_connection, to: ActiveRecord::Base
 
-      def initialize(configuration, root = ActiveRecord::Tasks::DatabaseTasks.root)
-        @configuration, @root = configuration, root
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config, root = ActiveRecord::Tasks::DatabaseTasks.root)
+        @db_config = db_config
+        @root = root
       end
 
       def create
-        raise DatabaseAlreadyExists if File.exist?(configuration["database"])
+        raise DatabaseAlreadyExists if File.exist?(db_config.database)
 
-        establish_connection configuration
+        establish_connection(db_config)
         connection
       end
 
       def drop
         require "pathname"
-        path = Pathname.new configuration["database"]
+        path = Pathname.new(db_config.database)
         file = path.absolute? ? path.to_s : File.join(root, path)
 
         FileUtils.rm(file)
@@ -40,7 +45,7 @@ module ActiveRecord
       def structure_dump(filename, extra_flags)
         args = []
         args.concat(Array(extra_flags)) if extra_flags
-        args << configuration["database"]
+        args << db_config.database
 
         ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
         if ignore_tables.any?
@@ -53,13 +58,12 @@ module ActiveRecord
       end
 
       def structure_load(filename, extra_flags)
-        dbfile = configuration["database"]
         flags = extra_flags.join(" ") if extra_flags
-        `sqlite3 #{flags} #{dbfile} < "#{filename}"`
+        `sqlite3 #{flags} #{db_config.database} < "#{filename}"`
       end
 
       private
-        attr_reader :configuration, :root
+        attr_reader :db_config, :root
 
         def run_cmd(cmd, args, out)
           fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, out: out)

data/lib/active_record/test_databases.rb

@@ -5,18 +5,19 @@ require "active_support/testing/parallelization"
 module ActiveRecord
   module TestDatabases # :nodoc:
     ActiveSupport::Testing::Parallelization.after_fork_hook do |i|
-      create_and_load_schema(i, env_name: Rails.env)
+      create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
     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.reconstruct_from_schema(db_config.config, ActiveRecord::Base.schema_format, nil, env_name, db_config.spec_name)
+        db_config._database = "#{db_config.database}-#{i}"
+
+        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord::Base.schema_format, nil)
       end
     ensure
-      ActiveRecord::Base.establish_connection(Rails.env.to_sym)
+      ActiveRecord::Base.establish_connection
       ENV["VERBOSE"] = old
     end
   end

data/lib/active_record/test_fixtures.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   module TestFixtures
     extend ActiveSupport::Concern
@@ -21,7 +23,6 @@ module ActiveRecord
       class_attribute :use_transactional_tests, default: true
       class_attribute :use_instantiated_fixtures, default: false # true, false, or :no_instances
       class_attribute :pre_loaded_fixtures, default: false
-      class_attribute :config, default: ActiveRecord::Base
       class_attribute :lock_threads, default: true
     end
 
@@ -41,8 +42,9 @@ module ActiveRecord
       def fixtures(*fixture_set_names)
         if fixture_set_names.first == :all
           raise StandardError, "No fixture path found. Please set `#{self}.fixture_path`." if fixture_path.blank?
-          fixture_set_names = Dir["#{fixture_path}/{**,*}/*.{yml}"].uniq
-          fixture_set_names.map! { |f| f[(fixture_path.to_s.size + 1)..-5] }
+          fixture_set_names = Dir[::File.join(fixture_path, "{**,*}/*.{yml}")].uniq
+          fixture_set_names.reject! { |f| f.start_with?(file_fixture_path.to_s) } if defined?(file_fixture_path) && file_fixture_path
+          fixture_set_names.map! { |f| f[fixture_path.to_s.size..-5].delete_prefix("/") }
         else
           fixture_set_names = fixture_set_names.flatten.map(&:to_s)
         end
@@ -97,7 +99,7 @@ module ActiveRecord
 
     def run_in_transaction?
       use_transactional_tests &&
-        !self.class.uses_transaction?(method_name)
+        !self.class.uses_transaction?(name)
     end
 
     def setup_fixtures(config = ActiveRecord::Base)
@@ -109,11 +111,11 @@ module ActiveRecord
       @fixture_connections = []
       @@already_loaded_fixtures ||= {}
       @connection_subscriber = nil
+      @legacy_saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+      @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
 
       # Load fixtures once and begin transaction.
       if run_in_transaction?
-        @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
-
         if @@already_loaded_fixtures[self.class]
           @loaded_fixtures = @@already_loaded_fixtures[self.class]
         else
@@ -131,19 +133,24 @@ 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
+          shard = payload[:shard] if payload.key?(:shard)
+          setup_shared_connection_pool if ActiveRecord::Base.legacy_connection_handling
 
           if spec_name
             begin
-              connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name)
+              connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
             rescue ConnectionNotEstablished
               connection = nil
             end
 
-            if connection && !@fixture_connections.include?(connection)
-              connection.begin_transaction joinable: false, _lazy: false
-              connection.pool.lock_thread = true if lock_threads
-              @fixture_connections << connection
+            if connection
+              setup_shared_connection_pool unless ActiveRecord::Base.legacy_connection_handling
+
+              if !@fixture_connections.include?(connection)
+                connection.begin_transaction joinable: false, _lazy: false
+                connection.pool.lock_thread = true if lock_threads
+                @fixture_connections << connection
+              end
             end
           end
         end
@@ -190,38 +197,79 @@ module ActiveRecord
       # need to share a connection pool so that the reading connection
       # can see data in the open transaction on the writing connection.
       def setup_shared_connection_pool
-        writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord::Base.writing_role]
-
-        ActiveRecord::Base.connection_handlers.values.each do |handler|
-          if handler != writing_handler
-            handler.connection_pool_list.each do |pool|
-              name = pool.spec.name
-              writing_connection = writing_handler.retrieve_connection_pool(name)
-              return unless writing_connection
-
-              reading_connection = handler.send(:owner_to_pool)[name]
-              next if reading_connection == writing_connection
-
-              @saved_pool_configs[handler][name] = reading_connection
-              handler.send(:owner_to_pool)[name] = writing_connection
+        if ActiveRecord::Base.legacy_connection_handling
+          writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord::Base.writing_role]
+
+          ActiveRecord::Base.connection_handlers.values.each do |handler|
+            if handler != writing_handler
+              handler.connection_pool_names.each do |name|
+                writing_pool_manager = writing_handler.send(:owner_to_pool_manager)[name]
+                return unless writing_pool_manager
+
+                pool_manager = handler.send(:owner_to_pool_manager)[name]
+                @legacy_saved_pool_configs[handler][name] ||= {}
+                pool_manager.shard_names.each do |shard_name|
+                  writing_pool_config = writing_pool_manager.get_pool_config(nil, shard_name)
+                  pool_config = pool_manager.get_pool_config(nil, shard_name)
+                  next if pool_config == writing_pool_config
+
+                  @legacy_saved_pool_configs[handler][name][shard_name] = pool_config
+                  pool_manager.set_pool_config(nil, shard_name, writing_pool_config)
+                end
+              end
+            end
+          end
+        else
+          handler = ActiveRecord::Base.connection_handler
+
+          handler.connection_pool_names.each do |name|
+            pool_manager = handler.send(:owner_to_pool_manager)[name]
+            pool_manager.shard_names.each do |shard_name|
+              writing_pool_config = pool_manager.get_pool_config(ActiveRecord::Base.writing_role, shard_name)
+              @saved_pool_configs[name][shard_name] ||= {}
+              pool_manager.role_names.each do |role|
+                next unless pool_config = pool_manager.get_pool_config(role, shard_name)
+                next if pool_config == writing_pool_config
+
+                @saved_pool_configs[name][shard_name][role] = pool_config
+                pool_manager.set_pool_config(role, shard_name, writing_pool_config)
+              end
             end
           end
         end
       end
 
       def teardown_shared_connection_pool
-        @saved_pool_configs.each_pair do |handler, pools|
-          pools.each_pair do |name, pool|
-            handler.send(:owner_to_pool)[name] = pool
+        if ActiveRecord::Base.legacy_connection_handling
+          @legacy_saved_pool_configs.each_pair do |handler, names|
+            names.each_pair do |name, shards|
+              shards.each_pair do |shard_name, pool_config|
+                pool_manager = handler.send(:owner_to_pool_manager)[name]
+                pool_manager.set_pool_config(nil, shard_name, pool_config)
+              end
+            end
+          end
+        else
+          handler = ActiveRecord::Base.connection_handler
+
+          @saved_pool_configs.each_pair do |name, shards|
+            pool_manager = handler.send(:owner_to_pool_manager)[name]
+            shards.each_pair do |shard_name, roles|
+              roles.each_pair do |role, pool_config|
+                next unless pool_manager.get_pool_config(role, shard_name)
+
+                pool_manager.set_pool_config(role, shard_name, pool_config)
+              end
+            end
           end
         end
 
+        @legacy_saved_pool_configs.clear
         @saved_pool_configs.clear
       end
 
       def load_fixtures(config)
-        fixtures = ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config)
-        Hash[fixtures.map { |f| [f.name, f] }]
+        ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config).index_by(&:name)
       end
 
       def instantiate_fixtures

data/lib/active_record/timestamp.rb

@@ -80,11 +80,11 @@ module ActiveRecord
 
       private
         def timestamp_attributes_for_create
-          ["created_at", "created_on"]
+          ["created_at", "created_on"].map! { |name| attribute_aliases[name] || name }
         end
 
         def timestamp_attributes_for_update
-          ["updated_at", "updated_on"]
+          ["updated_at", "updated_on"].map! { |name| attribute_aliases[name] || name }
         end
 
         def reload_schema_from_cache
@@ -101,9 +101,7 @@ module ActiveRecord
         current_time = current_time_from_proper_timezone
 
         all_timestamp_attributes_in_model.each do |column|
-          if !attribute_present?(column)
-            _write_attribute(column, current_time)
-          end
+          _write_attribute(column, current_time) unless _read_attribute(column)
         end
       end
 
@@ -159,7 +157,7 @@ module ActiveRecord
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|
         self[attribute_name] = nil
-        clear_attribute_changes([attribute_name])
+        clear_attribute_change(attribute_name)
       end
     end
   end

data/lib/active_record/touch_later.rb

@@ -3,22 +3,20 @@
 module ActiveRecord
   # = Active Record Touch Later
   module TouchLater # :nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      before_commit_without_transaction_enrollment :touch_deferred_attributes
+    def before_committed!
+      touch_deferred_attributes if has_defer_touch_attrs? && persisted?
+      super
     end
 
-    def touch_later(*names, **) # :nodoc:
-      unless persisted?
-        raise ActiveRecordError, <<-MSG.squish
-          cannot touch on a new or destroyed record object. Consider using
-          persisted?, new_record?, or destroyed? before touching
-        MSG
-      end
+    def touch_later(*names) # :nodoc:
+      _raise_record_not_touched_error unless persisted?
 
       @_defer_touch_attrs ||= timestamp_attributes_for_update_in_model
-      @_defer_touch_attrs |= names
+      @_defer_touch_attrs |= names.map! do |name|
+        name = name.to_s
+        self.class.attribute_aliases[name] || name
+      end unless names.empty?
+
       @_touch_time = current_time_from_proper_timezone
 
       surreptitiously_touch @_defer_touch_attrs
@@ -36,22 +34,24 @@ module ActiveRecord
     def touch(*names, time: nil) # :nodoc:
       if has_defer_touch_attrs?
         names |= @_defer_touch_attrs
+        super(*names, time: time)
+        @_defer_touch_attrs, @_touch_time = nil, nil
+      else
+        super
       end
-      super(*names, time: time)
     end
 
     private
-      def surreptitiously_touch(attrs)
-        attrs.each { |attr| write_attribute attr, @_touch_time }
-        clear_attribute_changes attrs
+      def surreptitiously_touch(attr_names)
+        attr_names.each do |attr_name|
+          _write_attribute(attr_name, @_touch_time)
+          clear_attribute_change(attr_name)
+        end
       end
 
       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
+        @_skip_dirty_tracking = true
+        touch(time: @_touch_time)
       end
 
       def has_defer_touch_attrs?

data/lib/active_record/transactions.rb

@@ -10,9 +10,6 @@ module ActiveRecord
     included do
       define_callbacks :commit, :rollback,
                        :before_commit,
-                       :before_commit_without_transaction_enrollment,
-                       :commit_without_transaction_enrollment,
-                       :rollback_without_transaction_enrollment,
                        scope: [:kind, :name]
     end
 
@@ -164,13 +161,13 @@ module ActiveRecord
     #     end
     #   end
     #
-    # only "Kotori" is created. This works on MySQL and PostgreSQL. SQLite3 version >= '3.6.8' also supports it.
+    # only "Kotori" is created.
     #
     # Most databases don't support true nested transactions. At the time of
     # writing, the only database that we're aware of that supports true nested
     # transactions, is MS-SQL. Because of this, Active Record emulates nested
-    # transactions by using savepoints on MySQL and PostgreSQL. See
-    # https://dev.mysql.com/doc/refman/5.7/en/savepoint.html
+    # transactions by using savepoints. See
+    # https://dev.mysql.com/doc/refman/en/savepoint.html
     # for more information about savepoints.
     #
     # === \Callbacks
@@ -266,21 +263,6 @@ module ActiveRecord
         set_callback(:rollback, :after, *args, &block)
       end
 
-      def before_commit_without_transaction_enrollment(*args, &block) # :nodoc:
-        set_options_for_callbacks!(args)
-        set_callback(:before_commit_without_transaction_enrollment, :before, *args, &block)
-      end
-
-      def after_commit_without_transaction_enrollment(*args, &block) # :nodoc:
-        set_options_for_callbacks!(args)
-        set_callback(:commit_without_transaction_enrollment, :after, *args, &block)
-      end
-
-      def after_rollback_without_transaction_enrollment(*args, &block) # :nodoc:
-        set_options_for_callbacks!(args)
-        set_callback(:rollback_without_transaction_enrollment, :after, *args, &block)
-      end
-
       private
         def set_options_for_callbacks!(args, enforced_options = {})
           options = args.extract_options!.merge!(enforced_options)
@@ -289,8 +271,10 @@ module ActiveRecord
           if options[:on]
             fire_on = Array(options[:on])
             assert_valid_transaction_action(fire_on)
-            options[:if] = Array(options[:if])
-            options[:if].unshift(-> { transaction_include_any_action?(fire_on) })
+            options[:if] = [
+              -> { transaction_include_any_action?(fire_on) },
+              *options[:if]
+            ]
           end
         end
 
@@ -302,7 +286,7 @@ module ActiveRecord
     end
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
-    def transaction(options = {}, &block)
+    def transaction(**options, &block)
       self.class.transaction(**options, &block)
     end
 
@@ -310,11 +294,11 @@ module ActiveRecord
       with_transaction_returning_status { super }
     end
 
-    def save(*, **) #:nodoc:
+    def save(**) #:nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save!(*, **) #:nodoc:
+    def save!(**) #:nodoc:
       with_transaction_returning_status { super }
     end
 
@@ -323,7 +307,6 @@ module ActiveRecord
     end
 
     def before_committed! # :nodoc:
-      _run_before_commit_without_transaction_enrollment_callbacks
       _run_before_commit_callbacks
     end
 
@@ -335,7 +318,6 @@ module ActiveRecord
       force_clear_transaction_record_state
       if should_run_callbacks
         @_committed_already_called = true
-        _run_commit_without_transaction_enrollment_callbacks
         _run_commit_callbacks
       end
     ensure
@@ -347,7 +329,6 @@ module ActiveRecord
     def rolledback!(force_restore_state: false, should_run_callbacks: true) #:nodoc:
       if should_run_callbacks
         _run_rollback_callbacks
-        _run_rollback_without_transaction_enrollment_callbacks
       end
     ensure
       restore_transaction_record_state(force_restore_state)
@@ -363,13 +344,11 @@ module ActiveRecord
     # instance.
     def with_transaction_returning_status
       status = nil
-      self.class.transaction do
-        if has_transactional_callbacks?
-          add_to_transaction
-        else
-          sync_with_transaction_state if @transaction_state&.finalized?
-          @transaction_state = self.class.connection.transaction_state
-        end
+      connection = self.class.connection
+      ensure_finalize = !connection.transaction_open?
+
+      connection.transaction do
+        add_to_transaction(ensure_finalize || has_transactional_callbacks?)
         remember_transaction_record_state
 
         status = yield
@@ -391,6 +370,7 @@ module ActiveRecord
         @_start_transaction_state ||= {
           id: id,
           new_record: @new_record,
+          previously_new_record: @previously_new_record,
           destroyed: @destroyed,
           attributes: @attributes,
           frozen?: frozen?,
@@ -415,7 +395,6 @@ module ActiveRecord
       # Force to clear the transaction record state.
       def force_clear_transaction_record_state
         @_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.
@@ -423,6 +402,7 @@ module ActiveRecord
         if restore_state = @_start_transaction_state
           if force_restore_state || restore_state[:level] <= 1
             @new_record = restore_state[:new_record]
+            @previously_new_record = restore_state[:previously_new_record]
             @destroyed  = restore_state[:destroyed]
             @attributes = restore_state[:attributes].map do |attr|
               value = @attributes.fetch_value(attr.name)
@@ -455,39 +435,12 @@ module ActiveRecord
 
       # 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)
+      def add_to_transaction(ensure_finalize = true)
+        self.class.connection.add_transaction_record(self, ensure_finalize)
       end
 
       def has_transactional_callbacks?
         !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_before_commit_callbacks.empty?
       end
-
-      # Updates the attributes on this particular Active Record object so that
-      # if it's associated with a transaction, then the state of the Active Record
-      # object will be updated to reflect the current state of the transaction.
-      #
-      # The <tt>@transaction_state</tt> variable stores the states of the associated
-      # transaction. This relies on the fact that a transaction can only be in
-      # one rollback or commit (otherwise a list of states would be required).
-      # Each Active Record object inside of a transaction carries that transaction's
-      # TransactionState.
-      #
-      # 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.
-      def sync_with_transaction_state
-        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
 end

data/lib/active_record/type/serialized.rb

@@ -61,9 +61,13 @@ module ActiveRecord
         end
 
         def encoded(value)
-          unless default_value?(value)
-            coder.dump(value)
+          return if default_value?(value)
+          payload = coder.dump(value)
+          if payload && binary? && payload.encoding != Encoding::BINARY
+            payload = payload.dup if payload.frozen?
+            payload.force_encoding(Encoding::BINARY)
           end
+          payload
         end
     end
   end