activerecord 7.0.0 → 7.1.2

data/lib/active_record/signed_id.rb

@@ -8,8 +8,8 @@ module ActiveRecord
     included do
       ##
       # :singleton-method:
-      # Set the secret used for the signed id verifier instance when using Active Record outside of Rails.
-      # Within Rails, this is automatically set using the Rails application key generator.
+      # Set the secret used for the signed id verifier instance when using Active Record outside of \Rails.
+      # Within \Rails, this is automatically set using the \Rails application key generator.
       class_attribute :signed_id_verifier_secret, instance_writer: false
     end
 
@@ -47,7 +47,7 @@ module ActiveRecord
         end
       end
 
-      # Works like +find_signed+, but will raise an +ActiveSupport::MessageVerifier::InvalidSignature+
+      # Works like find_signed, but will raise an +ActiveSupport::MessageVerifier::InvalidSignature+
       # exception if the +signed_id+ has either expired, has a purpose mismatch, is for another record,
       # or has been tampered with. It will also raise an +ActiveRecord::RecordNotFound+ exception if
       # the valid signed id can't find a record.
@@ -66,7 +66,7 @@ module ActiveRecord
       end
 
       # The verifier instance that all signed ids are generated and verified from. By default, it'll be initialized
-      # with the class-level +signed_id_verifier_secret+, which within Rails comes from the
+      # with the class-level +signed_id_verifier_secret+, which within \Rails comes from the
       # Rails.application.key_generator. By default, it's SHA256 for the digest and JSON for the serialization.
       def signed_id_verifier
         @signed_id_verifier ||= begin
@@ -97,7 +97,7 @@ module ActiveRecord
 
     # Returns a signed id that's generated using a preconfigured +ActiveSupport::MessageVerifier+ instance.
     # This signed id is tamper proof, so it's safe to send in an email or otherwise share with the outside world.
-    # It can further more be set to expire (the default is not to expire), and scoped down with a specific purpose.
+    # It can furthermore be set to expire (the default is not to expire), and scoped down with a specific purpose.
     # If the expiration date has been exceeded before +find_signed+ is called, the id won't find the designated
     # record. If a purpose is set, this too must match.
     #
@@ -109,8 +109,10 @@ module ActiveRecord
     #
     # And you then change your +find_signed+ calls to require this new purpose. Any old signed ids that were not
     # created with the purpose will no longer find the record.
-    def signed_id(expires_in: nil, purpose: nil)
-      self.class.signed_id_verifier.generate id, expires_in: expires_in, purpose: self.class.combine_signed_id_purposes(purpose)
+    def signed_id(expires_in: nil, expires_at: nil, purpose: nil)
+      raise ArgumentError, "Cannot get a signed_id for a new record" if new_record?
+
+      self.class.signed_id_verifier.generate id, expires_in: expires_in, expires_at: expires_at, purpose: self.class.combine_signed_id_purposes(purpose)
     end
   end
 end

data/lib/active_record/store.rb

@@ -3,6 +3,8 @@
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
+  # = Active Record \Store
+  #
   # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
   # It's like a simple key/value store baked into your record when you don't care about being able to
   # query that store outside the context of a single record.
@@ -59,7 +61,7 @@ module ActiveRecord
   #   u.color = 'green'
   #   u.color_changed? # => true
   #   u.color_was # => 'black'
-  #   u.color_change # => ['black', 'red']
+  #   u.color_change # => ['black', 'green']
   #
   #   # Add additional accessors to an existing store through store_accessor
   #   class SuperUser < User
@@ -70,7 +72,7 @@ module ActiveRecord
   #
   # The stored attribute names can be retrieved using {.stored_attributes}[rdoc-ref:rdoc-ref:ClassMethods#stored_attributes].
   #
-  #   User.stored_attributes[:settings] # [:color, :homepage, :two_factor_auth, :login_retry]
+  #   User.stored_attributes[:settings] # => [:color, :homepage, :two_factor_auth, :login_retry]
   #
   # == Overwriting default accessors
   #
@@ -102,7 +104,8 @@ module ActiveRecord
 
     module ClassMethods
       def store(store_attribute, options = {})
-        serialize store_attribute, IndifferentCoder.new(store_attribute, options[:coder])
+        coder = build_column_serializer(store_attribute, options[:coder], Object, options[:yaml])
+        serialize store_attribute, coder: IndifferentCoder.new(store_attribute, coder)
         store_accessor(store_attribute, options[:accessors], **options.slice(:prefix, :suffix)) if options.has_key? :accessors
       end
 
@@ -160,19 +163,19 @@ module ActiveRecord
 
             define_method("saved_change_to_#{accessor_key}?") do
               return false unless saved_change_to_attribute?(store_attribute)
-              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              prev_store, new_store = saved_changes[store_attribute]
               prev_store&.dig(key) != new_store&.dig(key)
             end
 
             define_method("saved_change_to_#{accessor_key}") do
               return unless saved_change_to_attribute?(store_attribute)
-              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              prev_store, new_store = saved_changes[store_attribute]
               [prev_store&.dig(key), new_store&.dig(key)]
             end
 
             define_method("#{accessor_key}_before_last_save") do
               return unless saved_change_to_attribute?(store_attribute)
-              prev_store, _new_store = saved_change_to_attribute(store_attribute)
+              prev_store, _new_store = saved_changes[store_attribute]
               prev_store&.dig(key)
             end
           end
@@ -225,10 +228,7 @@ module ActiveRecord
 
         def self.write(object, attribute, key, value)
           prepare(object, attribute)
-          if value != read(object, attribute, key)
-            object.public_send :"#{attribute}_will_change!"
-            object.public_send(attribute)[key] = value
-          end
+          object.public_send(attribute)[key] = value if value != read(object, attribute, key)
         end
 
         def self.prepare(object, attribute)
@@ -268,7 +268,7 @@ module ActiveRecord
         end
 
         def dump(obj)
-          @coder.dump self.class.as_indifferent_hash(obj)
+          @coder.dump as_regular_hash(obj)
         end
 
         def load(yaml)
@@ -285,6 +285,11 @@ module ActiveRecord
             ActiveSupport::HashWithIndifferentAccess.new
           end
         end
+
+        private
+          def as_regular_hash(obj)
+            obj.respond_to?(:to_hash) ? obj.to_hash : {}
+          end
       end
   end
 end

data/lib/active_record/suppressor.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveRecord
+  # = Active Record \Suppressor
+  #
   # ActiveRecord::Suppressor prevents the receiver from being saved during
   # a given block.
   #
@@ -32,7 +34,7 @@ module ActiveRecord
 
     class << self
       def registry # :nodoc:
-        ActiveSupport::IsolatedExecutionState[:active_record_suppresor_registry] ||= {}
+        ActiveSupport::IsolatedExecutionState[:active_record_suppressor_registry] ||= {}
       end
     end
 

data/lib/active_record/table_metadata.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   class TableMetadata # :nodoc:
-    delegate :join_primary_key, :join_foreign_key, :join_foreign_type, to: :reflection
+    delegate :join_primary_key, :join_primary_type, :join_foreign_key, :join_foreign_type, to: :reflection
 
     def initialize(klass, arel_table, reflection = nil)
       @klass = klass
@@ -19,11 +19,20 @@ module ActiveRecord
     end
 
     def has_column?(column_name)
-      klass&.columns_hash.key?(column_name)
+      klass&.columns_hash&.key?(column_name)
     end
 
     def associated_with?(table_name)
-      klass&._reflect_on_association(table_name) || klass&._reflect_on_association(table_name.singularize)
+      if reflection = klass&._reflect_on_association(table_name)
+        reflection
+      elsif ActiveRecord.allow_deprecated_singular_associations_name && reflection = klass&._reflect_on_association(table_name.singularize)
+        ActiveRecord.deprecator.warn(<<~MSG)
+          Referring to a singular association (e.g. `#{reflection.name}`) by its plural name (e.g. `#{reflection.plural_name}`) is deprecated.
+
+          To convert this deprecation warning to an error and enable more performant behavior, set config.active_record.allow_deprecated_singular_associations_name = false.
+        MSG
+        reflection
+      end
     end
 
     def associated_table(table_name)
@@ -54,6 +63,10 @@ module ActiveRecord
       reflection&.polymorphic?
     end
 
+    def polymorphic_name_association
+      reflection&.polymorphic_name
+    end
+
     def through_association?
       reflection&.through_reflection?
     end

data/lib/active_record/tasks/database_tasks.rb

@@ -6,14 +6,16 @@ module ActiveRecord
   module Tasks # :nodoc:
     class DatabaseNotSupported < StandardError; end # :nodoc:
 
+    # = Active Record \DatabaseTasks
+    #
     # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
     # logic behind common tasks used to manage database and migrations.
     #
-    # The tasks defined here are used with Rails commands provided by Active Record.
+    # The tasks defined here are used with \Rails commands provided by Active Record.
     #
     # In order to use DatabaseTasks, a few config values need to be set. All the needed
-    # config values are set by Rails already, so it's necessary to do it only if you
-    # want to change the defaults or when you want to use Active Record outside of Rails
+    # config values are set by \Rails already, so it's necessary to do it only if you
+    # want to change the defaults or when you want to use Active Record outside of \Rails
     # (in such case after configuring the database tasks, you can also use the rake tasks
     # defined in Active Record).
     #
@@ -27,7 +29,7 @@ module ActiveRecord
     # * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
     # * +root+: a path to the root of the application.
     #
-    # Example usage of DatabaseTasks outside Rails could look as such:
+    # Example usage of DatabaseTasks outside \Rails could look as such:
     #
     #   include ActiveRecord::Tasks
     #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
@@ -60,20 +62,12 @@ module ActiveRecord
 
       LOCAL_HOSTS = ["127.0.0.1", "localhost"]
 
-      def check_protected_environments!
-        unless ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
-          current = ActiveRecord::Base.connection.migration_context.current_environment
-          stored  = ActiveRecord::Base.connection.migration_context.last_stored_environment
-
-          if ActiveRecord::Base.connection.migration_context.protected_environment?
-            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
-          end
+      def check_protected_environments!(environment = env)
+        return if ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
 
-          if stored && stored != current
-            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
-          end
+        configs_for(env_name: environment).each do |db_config|
+          check_current_protected_environment!(db_config)
         end
-      rescue ActiveRecord::NoDatabaseError
       end
 
       def register_task(pattern, task)
@@ -82,6 +76,7 @@ module ActiveRecord
       end
 
       register_task(/mysql/,        "ActiveRecord::Tasks::MySQLDatabaseTasks")
+      register_task(/trilogy/,      "ActiveRecord::Tasks::MySQLDatabaseTasks")
       register_task(/postgresql/,   "ActiveRecord::Tasks::PostgreSQLDatabaseTasks")
       register_task(/sqlite/,       "ActiveRecord::Tasks::SQLiteDatabaseTasks")
 
@@ -130,28 +125,20 @@ module ActiveRecord
       end
 
       def create_all
-        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
+        db_config = migration_connection.pool.db_config
+
         each_local_configuration { |db_config| create(db_config) }
-        if old_pool
-          ActiveRecord::Base.connection_handler.establish_connection(old_pool.db_config)
-        end
+
+        migration_class.establish_connection(db_config)
       end
 
-      def setup_initial_database_yaml
+      def setup_initial_database_yaml # :nodoc:
         return {} unless defined?(Rails)
 
-        begin
-          Rails.application.config.load_database_yaml
-        rescue
-          unless ActiveRecord.suppress_multiple_database_warning
-            $stderr.puts "Rails couldn't infer whether you are using multiple databases from your database.yml and can't generate the tasks for the non-primary databases. If you'd like to use this feature, please simplify your ERB."
-          end
-
-          {}
-        end
+        Rails.application.config.load_database_yaml
       end
 
-      def for_each(databases)
+      def for_each(databases) # :nodoc:
         return {} unless defined?(Rails)
 
         database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)
@@ -166,7 +153,7 @@ module ActiveRecord
         end
       end
 
-      def raise_for_multi_db(environment = env, command:)
+      def raise_for_multi_db(environment = env, command:) # :nodoc:
         db_configs = configs_for(env_name: environment)
 
         if db_configs.count > 1
@@ -182,38 +169,35 @@ module ActiveRecord
 
       def create_current(environment = env, name = nil)
         each_current_configuration(environment, name) { |db_config| create(db_config) }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
+
+        migration_class.establish_connection(environment.to_sym)
       end
 
       def prepare_all
         seed = false
 
-        configs_for(env_name: env).each do |db_config|
-          ActiveRecord::Base.establish_connection(db_config)
+        each_current_configuration(env) do |db_config|
+          with_temporary_pool(db_config) do
+            begin
+              database_initialized = migration_connection.schema_migration.table_exists?
+            rescue ActiveRecord::NoDatabaseError
+              create(db_config)
+              retry
+            end
 
-          # Skipped when no database
-          migrate
+            unless database_initialized
+              if File.exist?(schema_dump_path(db_config))
+                load_schema(db_config, ActiveRecord.schema_format, nil)
+              end
+
+              seed = true
+            end
 
-          if ActiveRecord.dump_schema_after_migration
-            dump_schema(db_config, ActiveRecord.schema_format)
-          end
-        rescue ActiveRecord::NoDatabaseError
-          create_current(db_config.env_name, db_config.name)
-
-          if File.exist?(schema_dump_path(db_config))
-            load_schema(
-              db_config,
-              ActiveRecord.schema_format,
-              nil
-            )
-          else
             migrate
+            dump_schema(db_config) if ActiveRecord.dump_schema_after_migration
           end
-
-          seed = true
         end
 
-        ActiveRecord::Base.establish_connection
         load_seed if seed
       end
 
@@ -238,10 +222,9 @@ module ActiveRecord
       end
 
       def truncate_tables(db_config)
-        ActiveRecord::Base.establish_connection(db_config)
-
-        connection = ActiveRecord::Base.connection
-        connection.truncate_tables(*connection.tables)
+        with_temporary_connection(db_config) do |conn|
+          conn.truncate_tables(*conn.tables)
+        end
       end
       private :truncate_tables
 
@@ -252,18 +235,22 @@ module ActiveRecord
       end
 
       def migrate(version = nil)
-        check_target_version
-
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
-        Base.connection.migration_context.migrate(target_version || version) do |migration|
-          scope.blank? || scope == migration.scope
+        check_target_version
+
+        migration_connection.migration_context.migrate(target_version) do |migration|
+          if version.blank?
+            scope.blank? || scope == migration.scope
+          else
+            migration.version == version
+          end
         end.tap do |migrations_ran|
           Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end
 
-        ActiveRecord::Base.clear_cache!
+        migration_connection.schema_cache.clear!
       ensure
         Migration.verbose = verbose_was
       end
@@ -271,9 +258,9 @@ module ActiveRecord
       def db_configs_with_versions(db_configs) # :nodoc:
         db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
 
-        db_configs.each do |db_config|
-          ActiveRecord::Base.establish_connection(db_config)
-          versions_to_run = ActiveRecord::Base.connection.migration_context.pending_migration_versions
+        with_temporary_connection_for_each do |conn|
+          db_config = conn.pool.db_config
+          versions_to_run = conn.migration_context.pending_migration_versions
           target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
 
           versions_to_run.each do |version|
@@ -286,22 +273,22 @@ module ActiveRecord
       end
 
       def migrate_status
-        unless ActiveRecord::Base.connection.schema_migration.table_exists?
+        unless migration_connection.schema_migration.table_exists?
           Kernel.abort "Schema migrations table does not exist yet."
         end
 
         # output
-        puts "\ndatabase: #{ActiveRecord::Base.connection_db_config.database}\n\n"
+        puts "\ndatabase: #{migration_connection.pool.db_config.database}\n\n"
         puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
         puts "-" * 50
-        ActiveRecord::Base.connection.migration_context.migrations_status.each do |status, version, name|
+        migration_connection.migration_context.migrations_status.each do |status, version, name|
           puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
         end
         puts
       end
 
       def check_target_version
-        if target_version && !(Migration::MigrationFilenameRegexp.match?(ENV["VERSION"]) || /\A\d+\z/.match?(ENV["VERSION"]))
+        if target_version && !Migration.valid_version_format?(ENV["VERSION"])
           raise "Invalid format of target version: `VERSION=#{ENV['VERSION']}`"
         end
       end
@@ -341,7 +328,8 @@ module ActiveRecord
 
       def purge_current(environment = env)
         each_current_configuration(environment) { |db_config| purge(db_config) }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
+
+        migration_class.establish_connection(environment.to_sym)
       end
 
       def structure_dump(configuration, *arguments)
@@ -360,10 +348,10 @@ module ActiveRecord
 
       def load_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
         file ||= schema_dump_path(db_config, format)
+        return unless file
 
         verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
         check_schema_file(file)
-        ActiveRecord::Base.establish_connection(db_config)
 
         case format
         when :ruby
@@ -373,9 +361,8 @@ module ActiveRecord
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
-        ActiveRecord::InternalMetadata.create_table
-        ActiveRecord::InternalMetadata[:environment] = db_config.env_name
-        ActiveRecord::InternalMetadata[:schema_sha1] = schema_sha1(file)
+
+        migration_connection.internal_metadata.create_table_and_set_flags(db_config.env_name, schema_sha1(file))
       ensure
         Migration.verbose = verbose_was
       end
@@ -385,66 +372,58 @@ module ActiveRecord
 
         file ||= schema_dump_path(db_config)
 
-        return true unless File.exist?(file)
+        return true unless file && File.exist?(file)
 
-        ActiveRecord::Base.establish_connection(db_config)
+        with_temporary_connection(db_config) do |connection|
+          return false unless connection.internal_metadata.enabled?
+          return false unless connection.internal_metadata.table_exists?
 
-        return false unless ActiveRecord::InternalMetadata.enabled?
-        return false unless ActiveRecord::InternalMetadata.table_exists?
-
-        ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
+          connection.internal_metadata[:schema_sha1] == schema_sha1(file)
+        end
       end
 
       def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
         file ||= schema_dump_path(db_config, format)
 
-        check_schema_file(file)
-
-        ActiveRecord::Base.establish_connection(db_config)
+        check_schema_file(file) if file
 
-        if schema_up_to_date?(db_config, format, file)
-          truncate_tables(db_config)
-        else
-          purge(db_config)
+        with_temporary_pool(db_config, clobber: true) do
+          if schema_up_to_date?(db_config, format, file)
+            truncate_tables(db_config)
+          else
+            purge(db_config)
+            load_schema(db_config, format, file)
+          end
+        rescue ActiveRecord::NoDatabaseError
+          create(db_config)
           load_schema(db_config, format, file)
         end
-      rescue ActiveRecord::NoDatabaseError
-        create(db_config)
-        load_schema(db_config, format, file)
       end
 
       def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
+        return unless db_config.schema_dump
+
         require "active_record/schema_dumper"
         filename = schema_dump_path(db_config, format)
-        connection = ActiveRecord::Base.connection
+        return unless filename
 
         FileUtils.mkdir_p(db_dir)
         case format
         when :ruby
           File.open(filename, "w:utf-8") do |file|
-            ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+            ActiveRecord::SchemaDumper.dump(migration_connection, file)
           end
         when :sql
           structure_dump(db_config, filename)
-          if connection.schema_migration.table_exists?
+          if migration_connection.schema_migration.table_exists?
             File.open(filename, "a") do |f|
-              f.puts connection.dump_schema_information
+              f.puts migration_connection.dump_schema_information
               f.print "\n"
             end
           end
         end
       end
 
-      def schema_file_type(format = ActiveRecord.schema_format)
-        case format
-        when :ruby
-          "schema.rb"
-        when :sql
-          "structure.sql"
-        end
-      end
-      deprecate :schema_file_type
-
       def schema_dump_path(db_config, format = ActiveRecord.schema_format)
         return ENV["SCHEMA"] if ENV["SCHEMA"]
 
@@ -470,9 +449,10 @@ module ActiveRecord
 
       def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
         each_current_configuration(environment) do |db_config|
-          load_schema(db_config, format, file)
+          with_temporary_connection(db_config) do
+            load_schema(db_config, format, file)
+          end
         end
-        ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def check_schema_file(filename)
@@ -495,7 +475,7 @@ module ActiveRecord
 
       # Dumps the schema cache in YAML format for the connection into the file
       #
-      # ==== Examples:
+      # ==== Examples
       #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
       def dump_schema_cache(conn, filename)
         conn.schema_cache.dump_to(filename)
@@ -505,7 +485,41 @@ module ActiveRecord
         FileUtils.rm_f filename, verbose: false
       end
 
+      def with_temporary_connection_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, clobber: false, &block) # :nodoc:
+        if name
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: env, name: name)
+          with_temporary_connection(db_config, clobber: clobber, &block)
+        else
+          ActiveRecord::Base.configurations.configs_for(env_name: env, name: name).each do |db_config|
+            with_temporary_connection(db_config, clobber: clobber, &block)
+          end
+        end
+      end
+
+      def with_temporary_connection(db_config, clobber: false) # :nodoc:
+        with_temporary_pool(db_config, clobber: clobber) do |pool|
+          yield pool.connection
+        end
+      end
+
+      def migration_class # :nodoc:
+        ActiveRecord::Base
+      end
+
+      def migration_connection # :nodoc:
+        migration_class.connection
+      end
+
       private
+        def with_temporary_pool(db_config, clobber: false)
+          original_db_config = migration_class.connection_db_config
+          pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)
+
+          yield pool
+        ensure
+          migration_class.connection_handler.establish_connection(original_db_config, clobber: clobber)
+        end
+
         def configs_for(**options)
           Base.configurations.configs_for(**options)
         end
@@ -586,6 +600,23 @@ module ActiveRecord
             structure_load_flags
           end
         end
+
+        def check_current_protected_environment!(db_config)
+          with_temporary_pool(db_config) do |pool|
+            connection = pool.connection
+            current = connection.migration_context.current_environment
+            stored  = connection.migration_context.last_stored_environment
+
+            if connection.migration_context.protected_environment?
+              raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+            end
+
+            if stored && stored != current
+              raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+            end
+          rescue ActiveRecord::NoDatabaseError
+          end
+        end
     end
   end
 end