activerecord 7.2.0 → 7.2.2.1

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "concurrent/map"
+require "concurrent/atomic/atomic_fixnum"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -35,7 +36,9 @@ module ActiveRecord
         alias_method :enabled?, :enabled
         alias_method :dirties?, :dirties
 
-        def initialize(max_size)
+        def initialize(version, max_size)
+          @version = version
+          @current_version = version.value
           @map = {}
           @max_size = max_size
           @enabled = false
@@ -43,14 +46,17 @@ module ActiveRecord
         end
 
         def size
+          check_version
           @map.size
         end
 
         def empty?
+          check_version
           @map.empty?
         end
 
         def [](key)
+          check_version
           return unless @enabled
 
           if entry = @map.delete(key)
@@ -59,6 +65,8 @@ module ActiveRecord
         end
 
         def compute_if_absent(key)
+          check_version
+
           return yield unless @enabled
 
           if entry = @map.delete(key)
@@ -76,12 +84,40 @@ module ActiveRecord
           @map.clear
           self
         end
+
+        private
+          def check_version
+            if @current_version != @version.value
+              @map.clear
+              @current_version = @version.value
+            end
+          end
+      end
+
+      class QueryCacheRegistry # :nodoc:
+        def initialize
+          @mutex = Mutex.new
+          @map = ConnectionPool::WeakThreadKeyMap.new
+        end
+
+        def compute_if_absent(context)
+          @map[context] || @mutex.synchronize do
+            @map[context] ||= yield
+          end
+        end
+
+        def clear
+          @map.synchronize do
+            @map.clear
+          end
+        end
       end
 
       module ConnectionPoolConfiguration # :nodoc:
         def initialize(...)
           super
-          @thread_query_caches = Concurrent::Map.new(initial_capacity: @size)
+          @query_cache_version = Concurrent::AtomicFixnum.new
+          @thread_query_caches = QueryCacheRegistry.new
           @query_cache_max_size = \
             case query_cache = db_config&.query_cache
             when 0, false
@@ -121,11 +157,13 @@ module ActiveRecord
         end
 
         def enable_query_cache!
-          query_cache.enabled, query_cache.dirties = true, true
+          query_cache.enabled = true
+          query_cache.dirties = true
         end
 
         def disable_query_cache!
-          query_cache.enabled, query_cache.dirties = false, true
+          query_cache.enabled = false
+          query_cache.dirties = true
         end
 
         def query_cache_enabled
@@ -141,25 +179,16 @@ module ActiveRecord
             # With transactional fixtures, and especially systems test
             # another thread may use the same connection, but with a different
             # query cache. So we must clear them all.
-            @thread_query_caches.each_value(&:clear)
-          else
-            query_cache.clear
+            @query_cache_version.increment
           end
+          query_cache.clear
         end
 
         def query_cache
           @thread_query_caches.compute_if_absent(ActiveSupport::IsolatedExecutionState.context) do
-            Store.new(@query_cache_max_size)
+            Store.new(@query_cache_version, @query_cache_max_size)
           end
         end
-
-        private
-          def prune_thread_cache
-            dead_threads = @thread_query_caches.keys.reject(&:alive?)
-            dead_threads.each do |dead_thread|
-              @thread_query_caches.delete(dead_thread)
-            end
-          end
       end
 
       attr_accessor :query_cache

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

@@ -682,7 +682,7 @@ module ActiveRecord
       #
       # If the options provided include an +if_exists+ key, it will be used to check if the
       # column does not exist. This will silently ignore the migration rather than raising
-      # if the column was already used.
+      # if the column was already removed.
       #
       #   remove_column(:suppliers, :qualification, if_exists: true)
       def remove_column(table_name, column_name, type = nil, **options)

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -639,7 +639,7 @@ module ActiveRecord
       end
 
       def build_insert_sql(insert) # :nodoc:
-        no_op_column = quote_column_name(insert.keys.first)
+        no_op_column = quote_column_name(insert.keys.first) if insert.keys.first
 
         # MySQL 8.0.19 replaces `VALUES(<expression>)` clauses with row and column alias names, see https://dev.mysql.com/worklog/task/?id=6312 .
         # then MySQL 8.0.20 deprecates the `VALUES(<expression>)` see https://dev.mysql.com/worklog/task/?id=13325 .
@@ -648,7 +648,9 @@ module ActiveRecord
           sql = +"INSERT #{insert.into} #{insert.values_list} AS #{values_alias}"
 
           if insert.skip_duplicates?
-            sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{values_alias}.#{no_op_column}"
+            if no_op_column
+              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{values_alias}.#{no_op_column}"
+            end
           elsif insert.update_duplicates?
             if insert.raw_update_sql?
               sql = +"INSERT #{insert.into} #{insert.values_list} ON DUPLICATE KEY UPDATE #{insert.raw_update_sql}"
@@ -662,7 +664,9 @@ module ActiveRecord
           sql = +"INSERT #{insert.into} #{insert.values_list}"
 
           if insert.skip_duplicates?
-            sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{no_op_column}"
+            if no_op_column
+              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{no_op_column}"
+            end
           elsif insert.update_duplicates?
             sql << " ON DUPLICATE KEY UPDATE "
             if insert.raw_update_sql?

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

@@ -161,7 +161,7 @@ module ActiveRecord
           end
 
           def valid_primary_key_options
-            super + [:unsigned]
+            super + [:unsigned, :auto_increment]
           end
 
           def create_table_definition(name, **options)

data/lib/active_record/connection_adapters/postgresql/oid/cidr.rb

@@ -31,7 +31,7 @@ module ActiveRecord
           # TODO: Remove when IPAddr#== compares IPAddr#prefix. See
           # https://github.com/ruby/ipaddr/issues/21
           def changed?(old_value, new_value, _new_value_before_type_cast)
-            super || !old_value.nil? && old_value.prefix != new_value.prefix
+            !old_value.eql?(new_value) || !old_value.nil? && old_value.prefix != new_value.prefix
           end
 
           def cast_value(value)

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

@@ -255,6 +255,8 @@ module ActiveRecord
 
         # Returns the sequence name for a table's primary key or some other specified key.
         def default_sequence_name(table_name, pk = "id") # :nodoc:
+          return nil if pk.is_a?(Array)
+
           result = serial_sequence(table_name, pk)
           return nil unless result
           Utils.extract_schema_qualified_name(result).to_s

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -652,8 +652,8 @@ module ActiveRecord
           m.register_type "int4", Type::Integer.new(limit: 4)
           m.register_type "int8", Type::Integer.new(limit: 8)
           m.register_type "oid", OID::Oid.new
-          m.register_type "float4", Type::Float.new
-          m.alias_type "float8", "float4"
+          m.register_type "float4", Type::Float.new(limit: 24)
+          m.register_type "float8", Type::Float.new
           m.register_type "text", Type::Text.new
           register_class_with_limit m, "varchar", Type::String
           m.alias_type "char", "varchar"
@@ -777,7 +777,7 @@ module ActiveRecord
 
           case exception.result.try(:error_field, PG::PG_DIAG_SQLSTATE)
           when nil
-            if exception.message.match?(/connection is closed/i)
+            if exception.message.match?(/connection is closed/i) || exception.message.match?(/no connection to the server/i)
               ConnectionNotEstablished.new(exception, connection_pool: @pool)
             elsif exception.is_a?(PG::ConnectionBad)
               # libpq message style always ends with a newline; the pg gem's internal

data/lib/active_record/core.rb

@@ -102,8 +102,20 @@ module ActiveRecord
 
       class_attribute :shard_selector, instance_accessor: false, default: nil
 
-      # Specifies the attributes that will be included in the output of the #inspect method
-      class_attribute :attributes_for_inspect, instance_accessor: false, default: [:id]
+      ##
+      # :singleton-method:
+      #
+      # Specifies the attributes that will be included in the output of the
+      # #inspect method:
+      #
+      #   Post.attributes_for_inspect = [:id, :title]
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
+      #
+      # When set to `:all` inspect will list all the record's attributes:
+      #
+      #   Post.attributes_for_inspect = :all
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+      class_attribute :attributes_for_inspect, instance_accessor: false, default: :all
 
       def self.application_record_class? # :nodoc:
         if ActiveRecord.application_record_class
@@ -349,12 +361,12 @@ module ActiveRecord
 
       # Returns a string like 'Post(id:integer, title:string, body:text)'
       def inspect # :nodoc:
-        if self == Base
+        if self == Base || singleton_class?
           super
         elsif abstract_class?
           "#{super}(abstract)"
-        elsif !connected?
-          "#{super} (call '#{super}.lease_connection' to establish a connection)"
+        elsif !schema_loaded? && !connected?
+          "#{super} (call '#{super}.load_schema' to load schema informations)"
         elsif table_exists?
           attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
           "#{super}(#{attr_list})"
@@ -724,14 +736,28 @@ module ActiveRecord
       self.class.connection_handler
     end
 
-    # Returns the attributes specified by <tt>.attributes_for_inspect</tt> as a nicely formatted string.
+    # Returns the attributes of the record as a nicely formatted string.
+    #
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
+    # The attributes can be limited by setting <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.attributes_for_inspect = [:id, :title]
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!">"
     def inspect
       inspect_with_attributes(attributes_for_inspect)
     end
 
-    # Returns the full contents of the record as a nicely formatted string.
+    # Returns all attributes of the record as a nicely formatted string,
+    # ignoring <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.first.full_inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
     def full_inspect
-      inspect_with_attributes(attribute_names)
+      inspect_with_attributes(all_attributes_for_inspect)
     end
 
     # Takes a PP and prettily prints this record to it, allowing you to get a nice result from <tt>pp record</tt>
@@ -823,7 +849,13 @@ module ActiveRecord
       end
 
       def attributes_for_inspect
-        self.class.attributes_for_inspect == :all ? attribute_names : self.class.attributes_for_inspect
+        self.class.attributes_for_inspect == :all ? all_attributes_for_inspect : self.class.attributes_for_inspect
+      end
+
+      def all_attributes_for_inspect
+        return [] unless @attributes
+
+        attribute_names
       end
   end
 end

data/lib/active_record/database_configurations/connection_url_resolver.rb

@@ -45,7 +45,7 @@ module ActiveRecord
         attr_reader :uri
 
         def uri_parser
-          @uri_parser ||= URI::Parser.new
+          @uri_parser ||= URI::RFC2396_Parser.new
         end
 
         # Converts the query parameters of the URI into a hash.

data/lib/active_record/encryption/encryptable_record.rb

@@ -123,7 +123,7 @@ module ActiveRecord
             end)
           end
 
-          def load_schema!
+          def load_schema! # :nodoc:
             super
 
             add_length_validation_for_encrypted_columns if ActiveRecord::Encryption.config.validate_column_size

data/lib/active_record/encryption/encrypted_attribute_type.rb

@@ -7,13 +7,13 @@ module ActiveRecord
     # This is the central piece that connects the encryption system with +encrypts+ declarations in the
     # model classes. Whenever you declare an attribute as encrypted, it configures an +EncryptedAttributeType+
     # for that attribute.
-    class EncryptedAttributeType < ::ActiveRecord::Type::Text
+    class EncryptedAttributeType < ::ActiveModel::Type::Value
       include ActiveModel::Type::Helpers::Mutable
 
       attr_reader :scheme, :cast_type
 
       delegate :key_provider, :downcase?, :deterministic?, :previous_schemes, :with_context, :fixed?, to: :scheme
-      delegate :accessor, to: :cast_type
+      delegate :accessor, :type, to: :cast_type
 
       # === Options
       #

data/lib/active_record/encryption/encryptor.rb

@@ -46,7 +46,7 @@ module ActiveRecord
         serialize_message build_encrypted_message(clear_text, key_provider: key_provider, cipher_options: cipher_options)
       end
 
-      # Decrypts a +clean_text+ and returns the result as clean text
+      # Decrypts an +encrypted_text+ and returns the result as clean text
       #
       # === Options
       #

data/lib/active_record/encryption/key_provider.rb

@@ -12,7 +12,7 @@ module ActiveRecord
         @keys = Array(keys)
       end
 
-      # Returns the first key in the list as the active key to perform encryptions
+      # Returns the last key in the list as the active key to perform encryptions
       #
       # When +ActiveRecord::Encryption.config.store_key_references+ is true, the key will include
       # a public tag referencing the key itself. That key will be stored in the public

data/lib/active_record/encryption.rb

@@ -53,4 +53,6 @@ module ActiveRecord
       Cipher.eager_load!
     end
   end
+
+  ActiveSupport.run_load_hooks :active_record_encryption, Encryption
 end

data/lib/active_record/enum.rb

@@ -240,6 +240,7 @@ module ActiveRecord
 
       def _enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods: true, validate: false, **options)
         assert_valid_enum_definition_values(values)
+        assert_valid_enum_options(options)
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
         name = name.to_s
@@ -370,6 +371,13 @@ module ActiveRecord
         end
       end
 
+      def assert_valid_enum_options(options)
+        invalid_keys = options.keys & %i[_prefix _suffix _scopes _default _instance_methods]
+        unless invalid_keys.empty?
+          raise ArgumentError, "invalid option(s): #{invalid_keys.map(&:inspect).join(", ")}. Valid options are: :prefix, :suffix, :scopes, :default, :instance_methods, and :validate."
+        end
+      end
+
       ENUM_CONFLICT_MESSAGE = \
         "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
         "this will generate a %{type} method \"%{method}\", which is already defined " \

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 7
     MINOR = 2
-    TINY  = 0
-    PRE   = nil
+    TINY  = 2
+    PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/marshalling.rb

@@ -25,7 +25,10 @@ module ActiveRecord
         payload = [attributes_for_database, new_record?]
 
         cached_associations = self.class.reflect_on_all_associations.select do |reflection|
-          association_cached?(reflection.name) && association(reflection.name).loaded?
+          if association_cached?(reflection.name)
+            association = association(reflection.name)
+            association.loaded? || association.target.present?
+          end
         end
 
         unless cached_associations.empty?

data/lib/active_record/model_schema.rb

@@ -431,7 +431,6 @@ module ActiveRecord
       end
 
       def columns
-        load_schema unless @columns
         @columns ||= columns_hash.values.freeze
       end
 
@@ -531,7 +530,9 @@ module ActiveRecord
         initialize_find_by_cache
       end
 
-      def load_schema # :nodoc:
+      # Load the model's schema information either from the schema cache
+      # or directly from the database.
+      def load_schema
         return if schema_loaded?
         @load_schema_monitor.synchronize do
           return if schema_loaded?
@@ -592,6 +593,8 @@ module ActiveRecord
           columns_hash = schema_cache.columns_hash(table_name)
           columns_hash = columns_hash.except(*ignored_columns) unless ignored_columns.empty?
           @columns_hash = columns_hash.freeze
+
+          _default_attributes # Precompute to cache DB-dependent attribute types
         end
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.

data/lib/active_record/nested_attributes.rb

@@ -524,12 +524,12 @@ module ActiveRecord
             unless reject_new_record?(association_name, attributes)
               association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
             end
-          elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
+          elsif existing_record = find_record_by_id(existing_records, attributes["id"])
             unless call_reject_if(association_name, attributes)
               # Make sure we are operating on the actual object which is in the association's
               # proxy_target array (either by finding it, or adding it if not found)
               # Take into account that the proxy_target may have changed due to callbacks
-              target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
+              target_record = find_record_by_id(association.target, attributes["id"])
               if target_record
                 existing_record = target_record
               else
@@ -620,5 +620,16 @@ module ActiveRecord
         raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
                                  model, "id", record_id)
       end
+
+      def find_record_by_id(records, id)
+        return if records.empty?
+
+        if records.first.class.composite_primary_key?
+          id = Array(id).map(&:to_s)
+          records.find { |record| Array(record.id).map(&:to_s) == id }
+        else
+          records.find { |record| record.id.to_s == id.to_s }
+        end
+      end
   end
 end

data/lib/active_record/query_cache.rb

@@ -35,7 +35,10 @@ module ActiveRecord
     end
 
     def self.run
-      ActiveRecord::Base.connection_handler.each_connection_pool.reject(&:query_cache_enabled).each(&:enable_query_cache!)
+      ActiveRecord::Base.connection_handler.each_connection_pool.reject(&:query_cache_enabled).each do |pool|
+        next if pool.db_config&.query_cache == false
+        pool.enable_query_cache!
+      end
     end
 
     def self.complete(pools)
@@ -43,10 +46,6 @@ module ActiveRecord
         pool.disable_query_cache!
         pool.clear_query_cache
       end
-
-      ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
-        pool.release_connection if pool.active_connection? && !pool.lease_connection.transaction_open?
-      end
     end
 
     def self.install_executor_hooks(executor = ActiveSupport::Executor)

data/lib/active_record/query_logs.rb

@@ -112,7 +112,7 @@ module ActiveRecord
       if Thread.respond_to?(:each_caller_location)
         def query_source_location # :nodoc:
           Thread.each_caller_location do |location|
-            frame = LogSubscriber.backtrace_cleaner.clean_frame(location.path)
+            frame = LogSubscriber.backtrace_cleaner.clean_frame(location)
             return frame if frame
           end
           nil

data/lib/active_record/railtie.rb

@@ -69,6 +69,7 @@ module ActiveRecord
         Rails.logger.broadcast_to(console)
       end
       ActiveRecord.verbose_query_logs = false
+      ActiveRecord::Base.attributes_for_inspect = :all
     end
 
     runner do
@@ -311,6 +312,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
     initializer "active_record.set_executor_hooks" do
       ActiveRecord::QueryCache.install_executor_hooks
       ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks
+      ActiveRecord::ConnectionAdapters::ConnectionPool.install_executor_hooks
     end
 
     initializer "active_record.add_watchable_files" do |app|
@@ -356,16 +358,19 @@ To keep using the current cache store, you can turn off cache versioning entirel
     end
 
     initializer "active_record_encryption.configuration" do |app|
-      ActiveSupport.on_load(:active_record) do
-        ActiveRecord::Encryption.configure \
+      ActiveSupport.on_load(:active_record_encryption) do
+        ActiveRecord::Encryption.configure(
           primary_key: app.credentials.dig(:active_record_encryption, :primary_key),
           deterministic_key: app.credentials.dig(:active_record_encryption, :deterministic_key),
           key_derivation_salt: app.credentials.dig(:active_record_encryption, :key_derivation_salt),
           **app.config.active_record.encryption
+        )
 
         auto_filtered_parameters = ActiveRecord::Encryption::AutoFilteredParameters.new(app)
         auto_filtered_parameters.enable if ActiveRecord::Encryption.config.add_to_filter_parameters
+      end
 
+      ActiveSupport.on_load(:active_record) do
         # Support extended queries for deterministic attributes and validations
         if ActiveRecord::Encryption.config.extend_queries
           ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
@@ -432,15 +437,5 @@ To keep using the current cache store, you can turn off cache versioning entirel
         end
       end
     end
-
-    initializer "active_record.attributes_for_inspect" do |app|
-      ActiveSupport.on_load(:active_record) do
-        if app.config.consider_all_requests_local
-          if app.config.active_record.attributes_for_inspect.nil?
-            ActiveRecord::Base.attributes_for_inspect = :all
-          end
-        end
-      end
-    end
   end
 end

data/lib/active_record/reflection.rb

@@ -79,7 +79,7 @@ module ActiveRecord
         normalized_reflections.stringify_keys
       end
 
-      def normalized_reflections # :nodoc
+      def normalized_reflections # :nodoc:
         @__reflections ||= begin
           ref = {}
 
@@ -428,15 +428,19 @@ module ActiveRecord
       # a new association object. Use +build_association+ or +create_association+
       # instead. This allows plugins to hook into association object creation.
       def klass
-        @klass ||= compute_class(compute_name(class_name))
+        @klass ||= _klass(class_name)
       end
 
-      def compute_class(name)
-        name.constantize
+      def _klass(class_name) # :nodoc:
+        if active_record.name.demodulize == class_name
+          return compute_class("::#{class_name}") rescue NameError
+        end
+
+        compute_class(class_name)
       end
 
-      def compute_name(name) # :nodoc:
-        active_record.name.demodulize == name ? "::#{name}" : name
+      def compute_class(name)
+        name.constantize
       end
 
       # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
@@ -986,7 +990,7 @@ module ActiveRecord
       end
 
       def klass
-        @klass ||= delegate_reflection.compute_class(compute_name(class_name))
+        @klass ||= delegate_reflection._klass(class_name)
       end
 
       # Returns the source of the through reflection. It checks both a singularized
@@ -1235,7 +1239,10 @@ module ActiveRecord
       end
 
       def join_scopes(table, predicate_builder, klass = self.klass, record = nil) # :nodoc:
-        scopes = @previous_reflection.join_scopes(table, predicate_builder, klass, record) + super
+        scopes = super
+        unless @previous_reflection.through_reflection?
+          scopes += @previous_reflection.join_scopes(table, predicate_builder, klass, record)
+        end
         scopes << build_scope(table, predicate_builder, klass).instance_exec(record, &source_type_scope)
       end
 

data/lib/active_record/relation/batches.rb

@@ -241,14 +241,14 @@ module ActiveRecord
         raise ArgumentError, ":order must be :asc or :desc or an array consisting of :asc or :desc, got #{order.inspect}"
       end
 
-      unless block
-        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self, order: order, use_ranges: use_ranges)
-      end
-
       if arel.orders.present?
         act_on_ignored_order(error_on_ignore)
       end
 
+      unless block
+        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self, order: order, use_ranges: use_ranges)
+      end
+
       batch_limit = of
 
       if limit_value

data/lib/active_record/relation/calculations.rb

@@ -307,8 +307,8 @@ module ActiveRecord
         relation.pluck(*column_names)
       else
         klass.disallow_raw_sql!(flattened_args(column_names))
-        columns = arel_columns(column_names)
         relation = spawn
+        columns = relation.arel_columns(column_names)
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
           if where_clause.contradiction?