activerecord 6.1.0 → 6.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 418812373f3ff5fd16133fe0928b94b80b78b8a366abfc23a205fcb2ccc5a3e3
-  data.tar.gz: 70db1902a8fc82b1c46f8a7731ffb358357bc8cac29564a57881a732dbd2a65a
+  metadata.gz: 6cdd6094f92ff2d3eef67e5ab7f2a8e2a327fbdffaa1f20182fb5bdb7c803685
+  data.tar.gz: 197e68aa68f0946e9fcd55c7f0c2f41c237777c893b20a3a00affddbcaa1f367
 SHA512:
-  metadata.gz: 31ae64f629cb62f63bc37c74a888d557f9f0b102d401f2f9cf62c7d31655d99e5161ae9bc7f8be874c7a9cf27ec879dde3c04075df5cb2b5868891c0db144a50
-  data.tar.gz: cfc9585f3a6f53187707a9d96503269e3d4b1c5f1fe8c5f4db3bdefe8ce636042b6cf1fe9fb233491d1e8197f52293a7018a2f9925f1e34644ad1e30b134d59f
+  metadata.gz: 4b9b18c89048afe658359cd16b4c13c3a1eb87c8dacae3beeaf99338e2e441f64fd96bf569697cd581ea35f3068f33ee7872f733570f621a774c92b04253dc5e
+  data.tar.gz: 4d47d251881e21878596707b1d759f40b8b83a02e759cb1af79d8293498251a6ff3f5b11e4ecdc004ac282c6fc84437bcc60469bf0ed0a880aae1e820e20d4a1

data/CHANGELOG.md

@@ -1,3 +1,183 @@
+## Rails 6.1.3 (February 17, 2021) ##
+
+*   Fix the MySQL adapter to always set the right collation and charset
+    to the connection session.
+
+    *Rafael Mendonça França*
+
+*   Fix MySQL adapter handling of time objects when prepared statements
+    are enabled.
+
+    *Rafael Mendonça França*
+
+*   Fix scoping in enum fields using conditions that would generate
+    an `IN` clause.
+
+    *Ryuta Kamizono*
+
+*   Skip optimised #exist? query when #include? is called on a relation
+    with a having clause
+
+    Relations that have aliased select values AND a having clause that
+    references an aliased select value would generate an error when
+    #include? was called, due to an optimisation that would generate
+    call #exists? on the relation instead, which effectively alters
+    the select values of the query (and thus removes the aliased select
+    values), but leaves the having clause intact. Because the having
+    clause is then referencing an aliased column that is no longer
+    present in the simplified query, an ActiveRecord::InvalidStatement
+    error was raised.
+
+    An sample query affected by this problem:
+
+    ```ruby
+    Author.select('COUNT(*) as total_posts', 'authors.*')
+          .joins(:posts)
+          .group(:id)
+          .having('total_posts > 2')
+          .include?(Author.first)
+    ```
+
+    This change adds an addition check to the condition that skips the
+    simplified #exists? query, which simply checks for the presence of
+    a having clause.
+
+    Fixes #41417
+
+    *Michael Smart*
+
+*   Increment postgres prepared statement counter before making a prepared statement, so if the statement is aborted
+    without Rails knowledge (e.g., if app gets kill -9d during long-running query or due to Rack::Timeout), app won't end
+    up in perpetual crash state for being inconsistent with Postgres.
+
+    *wbharding*, *Martin Tepper*
+
+
+## Rails 6.1.2.1 (February 10, 2021) ##
+
+*   Fix possible DoS vector in PostgreSQL money type
+
+    Carefully crafted input can cause a DoS via the regular expressions used
+    for validating the money format in the PostgreSQL adapter.  This patch
+    fixes the regexp.
+
+    Thanks to @dee-see from Hackerone for this patch!
+
+    [CVE-2021-22880]
+
+    *Aaron Patterson*
+
+
+## Rails 6.1.2 (February 09, 2021) ##
+
+*   Fix timestamp type for sqlite3.
+
+    *Eileen M. Uchitelle*
+
+*   Make destroy async transactional.
+
+    An active record rollback could occur while enqueuing a job. In this
+    case the job would enqueue even though the database deletion
+    rolledback putting things in a funky state.
+
+    Now the jobs are only enqueued until after the db transaction has been committed.
+
+    *Cory Gwin*
+
+*   Fix malformed packet error in MySQL statement for connection configuration.
+
+    *robinroestenburg*
+
+*   Connection specification now passes the "url" key as a configuration for the
+    adapter if the "url" protocol is "jdbc", "http", or "https". Previously only
+    urls with the "jdbc" prefix were passed to the Active Record Adapter, others
+    are assumed to be adapter specification urls.
+
+    Fixes #41137.
+
+    *Jonathan Bracy*
+
+*   Fix granular connection swapping when there are multiple abstract classes.
+
+    *Eileen M. Uchitelle*
+
+*   Fix `find_by` with custom primary key for belongs_to association.
+
+    *Ryuta Kamizono*
+
+*   Add support for `rails console --sandbox` for multiple database applications.
+
+    *alpaca-tc*
+
+*   Fix `where` on polymorphic association with empty array.
+
+    *Ryuta Kamizono*
+
+*   Fix preventing writes for `ApplicationRecord`.
+
+    *Eileen M. Uchitelle*
+
+
+## Rails 6.1.1 (January 07, 2021) ##
+
+*   Fix fixtures loading when strict loading is enabled for the association.
+
+    *Alex Ghiculescu*
+
+*   Fix `where` with custom primary key for belongs_to association.
+
+    *Ryuta Kamizono*
+
+*   Fix `where` with aliased associations.
+
+    *Ryuta Kamizono*
+
+*   Fix `composed_of` with symbol mapping.
+
+    *Ryuta Kamizono*
+
+*   Don't skip money's type cast for pluck and calculations.
+
+    *Ryuta Kamizono*
+
+*   Fix `where` on polymorphic association with non Active Record object.
+
+    *Ryuta Kamizono*
+
+*   Make sure `db:prepare` works even the schema file doesn't exist.
+
+    *Rafael Mendonça França*
+
+*   Fix complicated `has_many :through` with nested where condition.
+
+    *Ryuta Kamizono*
+
+*   Handle STI models for `has_many dependent: :destroy_async`.
+
+    *Muhammad Usman*
+
+*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
+
+    Previously, passing `false` would trigger the option validation logic
+    to throw an error saying :polymorphic would not be a valid option.
+
+    *glaszig*
+
+*   Allow adding nonnamed expression indexes to be revertible.
+
+    Fixes #40732.
+
+    Previously, the following code would raise an error, when executed while rolling back,
+    and the index name should be specified explicitly. Now, the index name is inferred
+    automatically.
+
+    ```ruby
+    add_index(:items, "to_tsvector('english', description)")
+    ```
+
+    *fatkodima*
+
+
 ## Rails 6.1.0 (December 09, 2020) ##
 
 *   Only warn about negative enums if a positive form that would cause conflicts exists.
@@ -38,21 +218,21 @@
 
     Before:
 
-      AnimalsRecord.connected_to(role: :reading) do
-        MealsRecord.connected_to(role: :reading) do
-          Dog.first # read from animals replica
-          Dinner.first # read from meals replica
-          Person.first # read from primary writer
+        AnimalsRecord.connected_to(role: :reading) do
+          MealsRecord.connected_to(role: :reading) do
+            Dog.first # read from animals replica
+            Dinner.first # read from meals replica
+            Person.first # read from primary writer
+          end
         end
-      end
 
     After:
 
-      ActiveRecord::Base.connected_to_many([AnimalsRecord, MealsRecord], role: :reading) do
-        Dog.first # read from animals replica
-        Dinner.first # read from meals replica
-        Person.first # read from primary writer
-      end
+        ActiveRecord::Base.connected_to_many([AnimalsRecord, MealsRecord], role: :reading) do
+          Dog.first # read from animals replica
+          Dinner.first # read from meals replica
+          Person.first # read from primary writer
+        end
 
     *Eileen M. Uchitelle*, *John Crepezzi*
 
@@ -170,13 +350,13 @@
 
      Before:
 
-         User.where.not(name: "Jon", role: "admin")
-         # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
+        User.where.not(name: "Jon", role: "admin")
+        # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
 
      After:
 
-         User.where.not(name: "Jon", role: "admin")
-         # SELECT * FROM users WHERE NOT (name == 'Jon' AND role == 'admin')
+        User.where.not(name: "Jon", role: "admin")
+        # SELECT * FROM users WHERE NOT (name == 'Jon' AND role == 'admin')
 
     *Rafael Mendonça França*
 

data/README.rdoc

@@ -194,7 +194,7 @@ The latest version of Active Record can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/activerecord
+* https://github.com/rails/rails/tree/main/activerecord
 
 
 == License

data/lib/active_record/aggregations.rb

@@ -244,8 +244,8 @@ module ActiveRecord
         private
           def reader_method(name, class_name, mapping, allow_nil, constructor)
             define_method(name) do
-              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !_read_attribute(key).nil? })
-                attrs = mapping.collect { |key, _| _read_attribute(key) }
+              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !read_attribute(key).nil? })
+                attrs = mapping.collect { |key, _| read_attribute(key) }
                 object = constructor.respond_to?(:call) ?
                   constructor.call(*attrs) :
                   class_name.constantize.send(constructor, *attrs)
@@ -271,10 +271,10 @@ module ActiveRecord
               end
 
               if part.nil? && allow_nil
-                mapping.each { |key, _| self[key] = nil }
+                mapping.each { |key, _| write_attribute(key, nil) }
                 @aggregation_cache[name] = nil
               else
-                mapping.each { |key, value| self[key] = part.send(value) }
+                mapping.each { |key, value| write_attribute(key, part.send(value)) }
                 @aggregation_cache[name] = part.freeze
               end
             end

data/lib/active_record/association_relation.rb

@@ -27,6 +27,16 @@ module ActiveRecord
       RUBY
     end
 
+    def build(attributes = nil, &block)
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| build(attr, &block) }
+      else
+        block = current_scope_restoring_block(&block)
+        scoping { _new(attributes, &block) }
+      end
+    end
+    alias new build
+
     private
       def _new(attributes, &block)
         @association.build(attributes, &block)

data/lib/active_record/associations/association.rb

@@ -211,12 +211,8 @@ module ActiveRecord
 
       private
         def find_target
-          if owner.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: klass)
-          end
-
-          if reflection.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: reflection.name)
+          if (owner.strict_loading? || reflection.strict_loading?) && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
           scope = self.scope
@@ -331,7 +327,11 @@ module ActiveRecord
         end
 
         def enqueue_destroy_association(options)
-          owner.class.destroy_association_async_job&.perform_later(**options)
+          job_class = owner.class.destroy_association_async_job
+
+          if job_class
+            owner._after_commit_jobs.push([job_class, options])
+          end
         end
 
         def inversable?(record)

data/lib/active_record/associations/association_scope.rb

@@ -131,11 +131,13 @@ module ActiveRecord
               if scope_chain_item == chain_head.scope
                 scope.merge! item.except(:where, :includes, :unscope, :order)
               elsif !item.references_values.empty?
-                join_dependency = item.construct_join_dependency(
-                  item.eager_load_values | item.includes_values, Arel::Nodes::OuterJoin
-                )
-                scope.joins!(*item.joins_values, join_dependency)
-                scope.left_outer_joins!(*item.left_outer_joins_values)
+                scope.merge! item.only(:joins, :left_outer_joins)
+
+                associations = item.eager_load_values | item.includes_values
+
+                unless associations.empty?
+                  scope.joins! item.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
               end
 
               reflection.all_includes do

data/lib/active_record/associations/belongs_to_association.rb

@@ -80,7 +80,7 @@ module ActiveRecord
             @updated = true
           end
 
-          replace_keys(record)
+          replace_keys(record, force: true)
 
           self.target = record
         end
@@ -108,8 +108,12 @@ module ActiveRecord
           reflection.counter_cache_column && owner.persisted?
         end
 
-        def replace_keys(record)
-          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record.class)) : nil
+        def replace_keys(record, force: false)
+          target_key = record ? record._read_attribute(primary_key(record.class)) : nil
+
+          if force || owner[reflection.foreign_key] != target_key
+            owner[reflection.foreign_key] = target_key
+          end
         end
 
         def primary_key(klass)

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -14,9 +14,14 @@ module ActiveRecord
       end
 
       private
-        def replace_keys(record)
+        def replace_keys(record, force: false)
           super
-          owner[reflection.foreign_type] = record ? record.class.polymorphic_name : nil
+
+          target_type = record ? record.class.polymorphic_name : nil
+
+          if force || owner[reflection.foreign_type] != target_type
+            owner[reflection.foreign_type] = target_type
+          end
         end
 
         def inverse_reflection_for(record)

data/lib/active_record/associations/builder/association.rb

@@ -76,6 +76,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       if dependent = reflection.options[:dependent]
         check_dependent_options(dependent, model)
         add_destroy_callbacks(model, reflection)
+        add_after_commit_jobs_callback(model, dependent)
       end
 
       Association.extensions.each do |extension|
@@ -132,11 +133,31 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.add_destroy_callbacks(model, reflection)
       name = reflection.name
-      model.before_destroy lambda { |o| o.association(name).handle_dependency }
+      model.before_destroy(->(o) { o.association(name).handle_dependency })
+    end
+
+    def self.add_after_commit_jobs_callback(model, dependent)
+      if dependent == :destroy_async
+        mixin = model.generated_association_methods
+
+        unless mixin.method_defined?(:_after_commit_jobs)
+          model.after_commit(-> do
+            _after_commit_jobs.each do |job_class, job_arguments|
+              job_class.perform_later(**job_arguments)
+            end
+          end)
+
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def _after_commit_jobs
+              @_after_commit_jobs ||= []
+            end
+          CODE
+        end
+      end
     end
 
     private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
       :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
-      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks
+      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks, :add_after_commit_jobs_callback
   end
 end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -7,8 +7,8 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      valid = super + [:counter_cache, :optional, :default]
-      valid += [:polymorphic, :foreign_type] if options[:polymorphic]
+      valid = super + [:polymorphic, :counter_cache, :optional, :default]
+      valid += [:foreign_type] if options[:polymorphic]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
       valid
     end

data/lib/active_record/associations/has_many_association.rb

@@ -42,7 +42,7 @@ module ActiveRecord
             enqueue_destroy_association(
               owner_model_name: owner.class.to_s,
               owner_id: owner.id,
-              association_class: association_class.to_s,
+              association_class: reflection.klass.to_s,
               association_ids: ids,
               association_primary_key_column: primary_key_column,
               ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -42,16 +42,17 @@ module ActiveRecord
           chain.reverse_each do |reflection, table|
             klass = reflection.klass
 
-            join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+            scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            unless join_scope.references_values.empty?
-              join_dependency = join_scope.construct_join_dependency(
-                join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
-              )
-              join_scope.joins!(join_dependency)
+            unless scope.references_values.empty?
+              associations = scope.eager_load_values | scope.includes_values
+
+              unless associations.empty?
+                scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+              end
             end
 
-            arel = join_scope.arel(alias_tracker.aliases)
+            arel = scope.arel(alias_tracker.aliases)
             nodes = arel.constraints.first
 
             if nodes.is_a?(Arel::Nodes::And)

data/lib/active_record/associations/join_dependency.rb

@@ -195,7 +195,7 @@ module ActiveRecord
               next table, true
             end
 
-            table_name = @references[reflection.name.to_sym]
+            table_name = @references[reflection.name.to_sym]&.to_s
 
             table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
               name = reflection.alias_candidate(parent.table_name)

data/lib/active_record/associations.rb

@@ -1371,7 +1371,9 @@ module ActiveRecord
         #
         #   * <tt>nil</tt> do nothing (default).
         #   * <tt>:destroy</tt> causes all the associated objects to also be destroyed.
-        #   * <tt>:destroy_async</tt> destroys all the associated objects in a background job.
+        #   * <tt>:destroy_async</tt> destroys all the associated objects in a background job. <b>WARNING:</b> Do not use
+        #     this option if the association is backed by foreign key constraints in your database. The foreign key
+        #     constraint actions will occur inside the same transaction that deletes its owner.
         #   * <tt>:delete_all</tt> causes all the associated objects to be deleted directly from the database (so callbacks will not be executed).
         #   * <tt>:nullify</tt> causes the foreign keys to be set to +NULL+. Polymorphic type will also be nullified
         #     on polymorphic associations. Callbacks are not executed.
@@ -1523,7 +1525,9 @@ module ActiveRecord
         #
         #   * <tt>nil</tt> do nothing (default).
         #   * <tt>:destroy</tt> causes the associated object to also be destroyed
-        #   * <tt>:destroy_async</tt> causes all the associated object to be destroyed in a background job.
+        #   * <tt>:destroy_async</tt> causes the associated object to be destroyed in a background job. <b>WARNING:</b> Do not use
+        #     this option if the association is backed by foreign key constraints in your database. The foreign key
+        #     constraint actions will occur inside the same transaction that deletes its owner.
         #   * <tt>:delete</tt> causes the associated object to be deleted directly from the database (so callbacks will not execute)
         #   * <tt>:nullify</tt> causes the foreign key to be set to +NULL+. Polymorphic type column is also nullified
         #     on polymorphic associations. Callbacks are not executed.

data/lib/active_record/attributes.rb

@@ -173,7 +173,7 @@ module ActiveRecord
       #   class Money < Struct.new(:amount, :currency)
       #   end
       #
-      #   class MoneyType < Type::Value
+      #   class MoneyType < ActiveRecord::Type::Value
       #     def initialize(currency_converter:)
       #       @currency_converter = currency_converter
       #     end

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -24,7 +24,7 @@ module ActiveRecord
 
       attr_accessor :schema_cache
 
-      def owner_name
+      def connection_klass
         nil
       end
     end
@@ -360,7 +360,7 @@ module ActiveRecord
       include ConnectionAdapters::AbstractPool
 
       attr_accessor :automatic_reconnect, :checkout_timeout
-      attr_reader :db_config, :size, :reaper, :pool_config, :owner_name
+      attr_reader :db_config, :size, :reaper, :pool_config, :connection_klass
 
       delegate :schema_cache, :schema_cache=, to: :pool_config
 
@@ -375,7 +375,7 @@ module ActiveRecord
 
         @pool_config = pool_config
         @db_config = pool_config.db_config
-        @owner_name = pool_config.connection_specification_name
+        @connection_klass = pool_config.connection_klass
 
         @checkout_timeout = db_config.checkout_timeout
         @idle_timeout = db_config.idle_timeout
@@ -1040,7 +1040,7 @@ module ActiveRecord
       end
       alias :connection_pools :connection_pool_list
 
-      def establish_connection(config, owner_name: Base.name, role: ActiveRecord::Base.current_role, shard: Base.current_shard)
+      def establish_connection(config, owner_name: Base, role: ActiveRecord::Base.current_role, shard: Base.current_shard)
         owner_name = config.to_s if config.is_a?(Symbol)
 
         pool_config = resolve_pool_config(config, owner_name)

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -395,7 +395,7 @@ module ActiveRecord
 
       # Inserts the given fixture into the table. Overridden in adapters that require
       # something beyond a simple insert (e.g. Oracle).
-      # Most of adapters should implement `insert_fixtures_set` that leverages bulk SQL insert.
+      # Most of adapters should implement +insert_fixtures_set+ that leverages bulk SQL insert.
       # We keep this method to provide fallback
       # for databases like sqlite that do not support bulk inserts.
       def insert_fixture(fixture, table_name)

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -7,7 +7,7 @@ module ActiveRecord
     module QueryCache
       class << self
         def included(base) #:nodoc:
-          dirties_query_cache base, :insert, :update, :delete, :truncate, :truncate_tables,
+          dirties_query_cache base, :create, :insert, :update, :delete, :truncate, :truncate_tables,
             :rollback_to_savepoint, :rollback_db_transaction, :exec_insert_all
 
           base.set_callback :checkout, :after, :configure_query_cache!

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -71,6 +71,10 @@ module ActiveRecord
           end
         CODE
       end
+
+      def aliased_types(name, fallback)
+        "timestamp" == name ? :datetime : fallback
+      end
     end
 
     AddColumnDefinition = Struct.new(:column) # :nodoc:

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -1387,8 +1387,14 @@ module ActiveRecord
 
           checks = []
 
+          if !options.key?(:name) && column_name.is_a?(String) && /\W/.match?(column_name)
+            options[:name] = index_name(table_name, column_name)
+            column_names = []
+          else
+            column_names = index_column_names(column_name || options[:column])
+          end
+
           checks << lambda { |i| i.name == options[:name].to_s } if options.key?(:name)
-          column_names = index_column_names(column_name || options[:column])
 
           if column_names.present?
             checks << lambda { |i| index_name(table_name, i.columns) == index_name(table_name, column_names) }

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -111,22 +111,21 @@ module ActiveRecord
         @config.fetch(:use_metadata_table, true)
       end
 
-      # Determines whether writes are currently being prevents.
+      # Determines whether writes are currently being prevented.
       #
       # Returns true if the connection is a replica.
       #
       # If the application is using legacy handling, returns
-      # true if `connection_handler.prevent_writes` is set.
+      # true if +connection_handler.prevent_writes+ is set.
       #
       # If the application is using the new connection handling
-      # will return true based on `current_preventing_writes`.
+      # will return true based on +current_preventing_writes+.
       def preventing_writes?
         return true if replica?
         return ActiveRecord::Base.connection_handler.prevent_writes if ActiveRecord::Base.legacy_connection_handling
-        return false if owner_name.nil?
+        return false if connection_klass.nil?
 
-        klass = self.owner_name.safe_constantize
-        klass&.current_preventing_writes
+        connection_klass.current_preventing_writes
       end
 
       def migrations_paths # :nodoc:
@@ -202,8 +201,8 @@ module ActiveRecord
         @owner = Thread.current
       end
 
-      def owner_name # :nodoc:
-        @pool.owner_name
+      def connection_klass # :nodoc:
+        @pool.connection_klass
       end
 
       def schema_cache