Move schema loading monitor back up to model

We want to ensure attributes aren't defined concurrently, which
per-context monitors wouldn't prevent

Author: skipkayhil

activerecord/lib/active_record/model_schema.rb

@@ -544,16 +544,38 @@ def reset_column_information
 
       # Load the model's schema information either from the schema cache
       # or directly from the database.
+      #
+      # This separates two concerns:
+      # 1. Adapter-specific: populating the current Schema context's columns_hash
+      #    and default_attributes (runs per context, since different adapters may
+      #    return different column types).
+      # 2. Model-specific: the load_schema! super chain (counter_cache, encryption,
+      #    etc.) that mutates model-class-level state (runs once, since it's the
+      #    same regardless of adapter).
       def load_schema
-        model_schema.load_schema
+        return if schema_loaded?
+        @load_schema_monitor.synchronize do
+          return if schema_loaded?
+
+          model_schema.load_schema!
+
+          unless @model_schema_loaded
+            load_schema!
+            @model_schema_loaded = true
+          end
+        rescue
+          reload_schema_from_cache # If the schema loading failed half way through, we must reset the state.
+          raise
+        end
       end
 
       protected
         def initialize_load_schema_monitor
-          # No longer needed - each Schema has its own monitor
+          @load_schema_monitor = Monitor.new
         end
 
         def reload_schema_from_cache(recursive = true)
+          @model_schema_loaded = false
           @attribute_names = nil
 
           # Reset all Schema instances
@@ -578,11 +600,17 @@ def inherited(child_class)
         end
 
         def schema_loaded?
-          model_schema.send(:schema_loaded?)
+          model_schema.instance_variable_get(:@schema_loaded)
         end
 
         def load_schema!
-          model_schema.send(:load_schema!)
+          # Base implementation is a no-op. The adapter-specific schema loading
+          # (columns_hash, default_attributes) is handled by model_schema.load_schema!
+          # which is called directly from load_schema before this super chain.
+          #
+          # This method exists as the hook point for the super chain — overrides
+          # in CounterCache, EncryptableRecord, etc. call super and then do
+          # model-class-level setup that should only happen once.
         end
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.

activerecord/lib/active_record/model_schema/schema.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "monitor"
-
 module ActiveRecord
   module ModelSchema
     # Encapsulates all schema-context-dependent state for a model.
@@ -17,7 +15,6 @@ def initialize(model_class, context_key)
         @model_class = model_class
         @context_key = context_key
         @schema_loaded = false
-        @load_schema_monitor = Monitor.new
 
         # Schema-context-dependent state
         @columns_hash = nil
@@ -41,7 +38,7 @@ def initialize(model_class, context_key)
 
       # Returns the columns hash for this schema context
       def columns_hash
-        load_schema unless @columns_hash
+        model_class.send(:load_schema) unless @columns_hash
         @columns_hash
       end
 
@@ -115,7 +112,7 @@ def attributes_builder
 
       # Returns column defaults hash
       def column_defaults
-        load_schema
+        model_class.send(:load_schema)
         @column_defaults ||= _default_attributes.deep_dup.to_hash.freeze
       end
 
@@ -196,42 +193,30 @@ def initialize_find_by_cache
         @find_by_statement_cache = { true => Concurrent::Map.new, false => Concurrent::Map.new }
       end
 
-      # Load schema information from the schema cache
-      def load_schema
-        return if schema_loaded?
-        @load_schema_monitor.synchronize do
-          return if schema_loaded?
+      # Populate this schema context's columns and default attributes
+      # from the schema cache. Called by the model class's load_schema!.
+      def load_schema!
+        return if @schema_loaded
 
-          model_class.send(:load_schema!)
-          @schema_loaded = true
-        rescue
-          reload_schema_from_cache
-          raise
+        unless table_name
+          raise ActiveRecord::TableNotSpecified, "#{model_class} has no table configured. Set one with #{model_class}.table_name="
         end
-      end
 
-      private
-        def schema_loaded?
-          @schema_loaded
+        columns_hash = schema_cache.columns_hash(table_name)
+        if model_class.only_columns.present?
+          columns_hash = columns_hash.slice(*model_class.only_columns)
+        elsif model_class.ignored_columns.present?
+          columns_hash = columns_hash.except(*model_class.ignored_columns)
         end
+        @columns_hash = columns_hash.freeze
 
-        def load_schema!
-          unless table_name
-            raise ActiveRecord::TableNotSpecified, "#{model_class} has no table configured. Set one with #{model_class}.table_name="
-          end
+        # Precompute default attributes to cache DB-dependent attribute types
+        _default_attributes
 
-          columns_hash = schema_cache.columns_hash(table_name)
-          if model_class.only_columns.present?
-            columns_hash = columns_hash.slice(*model_class.only_columns)
-          elsif model_class.ignored_columns.present?
-            columns_hash = columns_hash.except(*model_class.ignored_columns)
-          end
-          @columns_hash = columns_hash.freeze
-
-          # Precompute default attributes to cache DB-dependent attribute types
-          _default_attributes
-        end
+        @schema_loaded = true
+      end
 
+      private
         def schema_cache
           connection_pool.schema_cache
         end