Enable models to connect/query different adapters.

Previously, models cached many adapter specific values which would
prevent making queries against different database types. Now, those
caches are per `schema_context`, which can be configured in
`database.yml`:

```yaml
primary:
  adapter: trilogy
  database: myapp_development
primary_pg:
  adapter: postgresql
  database: myapp_development
  schema_context: pg
```

This enables models to connect to both MySQL and PostgreSQL databases in
the same application, and query them successfully:

```ruby
class User < ApplicationRecord
  connects_to shards: {
    mysql: { writing: :primary, reading: :primary },
    pg: { writing: :primary_pg, reading: :primary_pg },
  }
end

User.connected_to(shard: :mysql) { User.first } # queries MySQL
User.connected_to(shard: :pg) { User.first } # queries PostgreSQL
```

Author: skipkayhil

activemodel/lib/active_model/attribute_registration.rb

@@ -55,6 +55,16 @@ def type_for_attribute(attribute_name, &block)
         end
       end
 
+      def apply_pending_attribute_modifications(attribute_set) # :nodoc:
+        if superclass.respond_to?(:apply_pending_attribute_modifications, true)
+          superclass.send(:apply_pending_attribute_modifications, attribute_set)
+        end
+
+        pending_attribute_modifications.each do |modification|
+          modification.apply_to(attribute_set)
+        end
+      end
+
       private
         PendingType = Struct.new(:name, :type) do # :nodoc:
           def apply_to(attribute_set)
@@ -83,16 +93,6 @@ def pending_attribute_modifications
           @pending_attribute_modifications ||= []
         end
 
-        def apply_pending_attribute_modifications(attribute_set)
-          if superclass.respond_to?(:apply_pending_attribute_modifications, true)
-            superclass.send(:apply_pending_attribute_modifications, attribute_set)
-          end
-
-          pending_attribute_modifications.each do |modification|
-            modification.apply_to(attribute_set)
-          end
-        end
-
         def reset_default_attributes
           reset_default_attributes!
           subclasses.each { |subclass| subclass.send(:reset_default_attributes) }

activerecord/CHANGELOG.md

@@ -1,3 +1,37 @@
+*   Enable experimental support for models to connect to and query databases
+    with different adapters.
+
+    Previously, models cached many adapter specific values which would prevent
+    making queries against different database types. Now, those caches are per
+    `schema_context`, which can be configured in `database.yml`:
+
+    ```yaml
+    primary:
+      adapter: trilogy
+      database: myapp_development
+    primary_pg:
+      adapter: postgresql
+      database: myapp_development
+      schema_context: pg
+    ```
+
+    This enables models to connect to both MySQL and PostgreSQL databases in the
+    same application, and query them successfully:
+
+    ```ruby
+    class User < ApplicationRecord
+      connects_to shards: {
+        mysql: { writing: :primary, reading: :primary },
+        pg: { writing: :primary_pg, reading: :primary_pg },
+      }
+    end
+
+    User.connected_to(shard: :mysql) { User.first } # queries MySQL
+    User.connected_to(shard: :pg) { User.first } # queries PostgreSQL
+    ```
+
+    *Hartley McGuire*
+
 *   Batch SQL statements when creating tables to improve performance.
 
     *Andrew Novoselac*

activerecord/lib/active_record/attributes.rb

@@ -251,15 +251,15 @@ def define_attribute(
       end
 
       def _default_attributes # :nodoc:
-        @default_attributes ||= begin
-          attributes_hash = columns_hash.transform_values do |column|
-            ActiveModel::Attribute.from_database(column.name, column.default, type_for_column(column))
-          end
+        model_schema._default_attributes
+      end
 
-          attribute_set = ActiveModel::AttributeSet.new(attributes_hash)
-          apply_pending_attribute_modifications(attribute_set)
-          attribute_set
-        end
+      def attribute_types # :nodoc:
+        model_schema.attribute_types
+      end
+
+      def type_for_column(column) # :nodoc:
+        hook_attribute_type(column.name, super)
       end
 
       ##
@@ -307,10 +307,6 @@ def reset_default_attributes
         def resolve_type_name(name, **options)
           Type.lookup(name, **options, adapter: Type.adapter_name_from(self))
         end
-
-        def type_for_column(column)
-          hook_attribute_type(column.name, super)
-        end
     end
   end
 end

activerecord/lib/active_record/core.rb

@@ -263,7 +263,7 @@ def self.strict_loading_violation!(owner:, reflection:) # :nodoc:
 
     module ClassMethods
       def initialize_find_by_cache # :nodoc:
-        @find_by_statement_cache = { true => Concurrent::Map.new, false => Concurrent::Map.new }
+        model_schemas.each_value(&:initialize_find_by_cache)
       end
 
       def find(*ids) # :nodoc:
@@ -412,8 +412,7 @@ def type_caster # :nodoc:
       end
 
       def cached_find_by_statement(connection, key, &block) # :nodoc:
-        cache = @find_by_statement_cache[connection.prepared_statements]
-        cache.compute_if_absent(key) { StatementCache.create(connection, &block) }
+        model_schema.cached_find_by_statement(connection, key, &block)
       end
 
       private

activerecord/lib/active_record/database_configurations/hash_config.rb

@@ -195,6 +195,10 @@ def use_metadata_table? # :nodoc:
         configuration_hash.fetch(:use_metadata_table, true)
       end
 
+      def schema_context # :nodoc:
+        configuration_hash.fetch(:schema_context, "default").to_s
+      end
+
       private
         def schema_file_type(format)
           case format.to_sym

activerecord/lib/active_record/model_schema.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "monitor"
+require "active_record/model_schema/schema"
 
 module ActiveRecord
   module ModelSchema
@@ -199,6 +200,21 @@ def self.derive_join_table_name(first_table, second_table) # :nodoc:
     end
 
     module ClassMethods
+      def current_schema_context # :nodoc:
+        connection_db_config.schema_context
+      rescue ConnectionNotDefined
+        "default"
+      end
+
+      def model_schema # :nodoc:
+        context_key = current_schema_context
+        model_schemas[context_key] ||= Schema.new(self, context_key)
+      end
+
+      def model_schemas # :nodoc:
+        @model_schemas ||= {}
+      end
+
       # Guesses the table name (in forced lower-case) based on the name of the class in the
       # inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy
       # looks like: Reply < Message < ActiveRecord::Base, then Message is used
@@ -448,29 +464,19 @@ def table_exists?
       end
 
       def attributes_builder # :nodoc:
-        @attributes_builder ||= begin
-          defaults = _default_attributes.except(*(column_names - [primary_key]))
-          ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
-        end
+        model_schema.attributes_builder
       end
 
       def columns_hash # :nodoc:
-        load_schema unless @columns_hash
-        @columns_hash
+        model_schema.columns_hash
       end
 
       def columns
-        @columns ||= columns_hash.values.freeze
+        model_schema.columns
       end
 
       def _returning_columns_for_insert(connection) # :nodoc:
-        @_returning_columns_for_insert ||= begin
-          auto_populated_columns = columns.filter_map do |c|
-            c.name if connection.return_value_after_insert?(c)
-          end
-
-          auto_populated_columns.empty? ? Array(primary_key) : auto_populated_columns
-        end
+        model_schema._returning_columns_for_insert(connection)
       end
 
       # Returns the column object for the named attribute.
@@ -496,28 +502,22 @@ def column_for_attribute(name)
       # Returns a hash where the keys are column names and the values are
       # default values when instantiating the Active Record object for this table.
       def column_defaults
-        load_schema
-        @column_defaults ||= _default_attributes.deep_dup.to_hash.freeze
+        model_schema.column_defaults
       end
 
       # Returns an array of column names as strings.
       def column_names
-        @column_names ||= columns.map(&:name).freeze
+        model_schema.column_names
       end
 
       def symbol_column_to_string(name_symbol) # :nodoc:
-        @symbol_column_to_string_name_hash ||= column_names.index_by(&:to_sym)
-        @symbol_column_to_string_name_hash[name_symbol]
+        model_schema.symbol_column_to_string(name_symbol)
       end
 
       # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
       # and columns used for single table inheritance have been removed.
       def content_columns
-        @content_columns ||= columns.reject do |c|
-          c.name == primary_key ||
-          c.name == inheritance_column ||
-          c.name.end_with?("_id", "_count")
-        end.freeze
+        model_schema.content_columns
       end
 
       # Resets all the cached information about columns, which will cause them
@@ -557,14 +557,25 @@ 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
         return if schema_loaded?
         @load_schema_monitor.synchronize do
           return if schema_loaded?
 
-          load_schema!
+          model_schema.load_schema!
 
-          @schema_loaded = true
+          unless @any_schema_loaded
+            load_schema!
+            @any_schema_loaded = true
+          end
         rescue
           reload_schema_from_cache # If the schema loading failed half way through, we must reset the state.
           raise
@@ -577,17 +588,13 @@ def initialize_load_schema_monitor
         end
 
         def reload_schema_from_cache(recursive = true)
-          @_returning_columns_for_insert = nil
+          @any_schema_loaded = false
           @arel_table = nil
-          @column_names = nil
-          @symbol_column_to_string_name_hash = nil
-          @content_columns = nil
-          @column_defaults = nil
-          @attributes_builder = nil
-          @columns = nil
-          @columns_hash = nil
-          @schema_loaded = false
           @attribute_names = nil
+
+          # Reset all Schema instances
+          model_schemas.each_value(&:reload_schema_from_cache)
+
           if recursive
             subclasses.each do |descendant|
               descendant.send(:reload_schema_from_cache)
@@ -607,23 +614,17 @@ def inherited(child_class)
         end
 
         def schema_loaded?
-          @schema_loaded
+          model_schema.schema_loaded?
         end
 
         def load_schema!
-          unless table_name
-            raise ActiveRecord::TableNotSpecified, "#{self} has no table configured. Set one with #{self}.table_name="
-          end
-
-          columns_hash = schema_cache.columns_hash(table_name)
-          if only_columns.present?
-            columns_hash = columns_hash.slice(*only_columns)
-          elsif ignored_columns.present?
-            columns_hash = columns_hash.except(*ignored_columns)
-          end
-          @columns_hash = columns_hash.freeze
-
-          _default_attributes # Precompute to cache DB-dependent attribute types
+          # 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.