activerecord 5.0.7 → 5.1.7

data/lib/active_record/relation/record_fetch_warning.rb

@@ -2,15 +2,15 @@ module ActiveRecord
   class Relation
     module RecordFetchWarning
       # When this module is prepended to ActiveRecord::Relation and
-      # `config.active_record.warn_on_records_fetched_greater_than` is
+      # +config.active_record.warn_on_records_fetched_greater_than+ is
       # set to an integer, if the number of records a query returns is
-      # greater than the value of `warn_on_records_fetched_greater_than`,
+      # greater than the value of +warn_on_records_fetched_greater_than+,
       # a warning is logged. This allows for the detection of queries that
       # return a large number of records, which could cause memory bloat.
       #
       # In most cases, fetching large number of records can be performed
       # efficiently using the ActiveRecord::Batches methods.
-      # See active_record/lib/relation/batches.rb for more information.
+      # See ActiveRecord::Batches for more information.
       def exec_queries
         QueryRegistry.reset
 

data/lib/active_record/relation/spawn_methods.rb

@@ -1,10 +1,9 @@
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
-require 'active_record/relation/merger'
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
+require "active_record/relation/merger"
 
 module ActiveRecord
   module SpawnMethods
-
     # This is overridden by Associations::CollectionProxy
     def spawn #:nodoc:
       clone
@@ -67,7 +66,7 @@ module ActiveRecord
 
     private
 
-      def relation_with(values) # :nodoc:
+      def relation_with(values)
         result = Relation.create(klass, table, predicate_builder, values)
         result.extend(*extending_values) if extending_values.any?
         result

data/lib/active_record/relation/where_clause.rb

@@ -25,10 +25,7 @@ module ActiveRecord
       end
 
       def except(*columns)
-        WhereClause.new(
-          predicates_except(columns),
-          binds_except(columns),
-        )
+        WhereClause.new(*except_predicates_and_binds(columns))
       end
 
       def or(other)
@@ -84,91 +81,109 @@ module ActiveRecord
         @empty ||= new([], [])
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :predicates
+        attr_reader :predicates
 
-      def referenced_columns
-        @referenced_columns ||= begin
-          equality_nodes = predicates.select { |n| equality_node?(n) }
-          Set.new(equality_nodes, &:left)
+        def referenced_columns
+          @referenced_columns ||= begin
+            equality_nodes = predicates.select { |n| equality_node?(n) }
+            Set.new(equality_nodes, &:left)
+          end
         end
-      end
 
       private
 
-      def predicates_unreferenced_by(other)
-        predicates.reject do |n|
-          equality_node?(n) && other.referenced_columns.include?(n.left)
+        def predicates_unreferenced_by(other)
+          predicates.reject do |n|
+            equality_node?(n) && other.referenced_columns.include?(n.left)
+          end
         end
-      end
-
-      def equality_node?(node)
-        node.respond_to?(:operator) && node.operator == :==
-      end
 
-      def non_conflicting_binds(other)
-        conflicts = referenced_columns & other.referenced_columns
-        conflicts.map! { |node| node.name.to_s }
-        binds.reject { |attr| conflicts.include?(attr.name) }
-      end
+        def equality_node?(node)
+          node.respond_to?(:operator) && node.operator == :==
+        end
 
-      def inverted_predicates
-        predicates.map { |node| invert_predicate(node) }
-      end
+        def non_conflicting_binds(other)
+          conflicts = referenced_columns & other.referenced_columns
+          conflicts.map! { |node| node.name.to_s }
+          binds.reject { |attr| conflicts.include?(attr.name) }
+        end
 
-      def invert_predicate(node)
-        case node
-        when NilClass
-          raise ArgumentError, 'Invalid argument for .where.not(), got nil.'
-        when Arel::Nodes::In
-          Arel::Nodes::NotIn.new(node.left, node.right)
-        when Arel::Nodes::Equality
-          Arel::Nodes::NotEqual.new(node.left, node.right)
-        when String
-          Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(node))
-        else
-          Arel::Nodes::Not.new(node)
+        def inverted_predicates
+          predicates.map { |node| invert_predicate(node) }
         end
-      end
 
-      def predicates_except(columns)
-        predicates.reject do |node|
+        def invert_predicate(node)
           case node
-          when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
-            subrelation = (node.left.kind_of?(Arel::Attributes::Attribute) ? node.left : node.right)
-            columns.include?(subrelation.name.to_s)
+          when NilClass
+            raise ArgumentError, "Invalid argument for .where.not(), got nil."
+          when Arel::Nodes::In
+            Arel::Nodes::NotIn.new(node.left, node.right)
+          when Arel::Nodes::Equality
+            Arel::Nodes::NotEqual.new(node.left, node.right)
+          when String
+            Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(node))
+          else
+            Arel::Nodes::Not.new(node)
           end
         end
-      end
 
-      def binds_except(columns)
-        binds.reject do |attr|
-          columns.include?(attr.name)
+        def except_predicates_and_binds(columns)
+          except_binds = []
+          binds_index = 0
+
+          predicates = self.predicates.reject do |node|
+            binds_contains = node.grep(Arel::Nodes::BindParam).size if node.is_a?(Arel::Nodes::Node)
+
+            except = \
+              case node
+              when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
+                subrelation = (node.left.kind_of?(Arel::Attributes::Attribute) ? node.left : node.right)
+                columns.include?(subrelation.name.to_s)
+              end
+
+            if except && binds_contains > 0
+              (binds_index...(binds_index + binds_contains)).each do |i|
+                except_binds[i] = true
+              end
+            end
+
+            binds_index += binds_contains if binds_contains
+
+            except
+          end
+
+          binds = self.binds.reject.with_index do |_, i|
+            except_binds[i]
+          end
+
+          [predicates, binds]
         end
-      end
 
-      def predicates_with_wrapped_sql_literals
-        non_empty_predicates.map do |node|
-          if Arel::Nodes::Equality === node
-            node
-          else
-            wrap_sql_literal(node)
+        def predicates_with_wrapped_sql_literals
+          non_empty_predicates.map do |node|
+            if Arel::Nodes::Equality === node
+              node
+            else
+              wrap_sql_literal(node)
+            end
           end
         end
-      end
 
-      ARRAY_WITH_EMPTY_STRING = ['']
-      def non_empty_predicates
-        predicates - ARRAY_WITH_EMPTY_STRING
-      end
+        ARRAY_WITH_EMPTY_STRING = [""]
+        def non_empty_predicates
+          predicates - ARRAY_WITH_EMPTY_STRING
+        end
 
-      def wrap_sql_literal(node)
-        if ::String === node
-          node = Arel.sql(node)
+        def wrap_sql_literal(node)
+          if ::String === node
+            node = Arel.sql(node)
+          end
+          Arel::Nodes::Grouping.new(node)
         end
-        Arel::Nodes::Grouping.new(node)
-      end
     end
   end
 end

data/lib/active_record/relation/where_clause_factory.rb

@@ -7,8 +7,6 @@ module ActiveRecord
       end
 
       def build(opts, other)
-        binds = []
-
         case opts
         when String, Array
           parts = [klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
@@ -17,22 +15,63 @@ module ActiveRecord
           attributes = klass.send(:expand_hash_conditions_for_aggregates, attributes)
           attributes.stringify_keys!
 
-          attributes, binds = predicate_builder.create_binds(attributes)
-
-          parts = predicate_builder.build_from_hash(attributes)
+          if perform_case_sensitive?(options = other.last)
+            parts, binds = build_for_case_sensitive(attributes, options)
+          else
+            attributes, binds = predicate_builder.create_binds(attributes)
+            parts = predicate_builder.build_from_hash(attributes)
+          end
         when Arel::Nodes::Node
           parts = [opts]
-          binds = other
         else
           raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
         end
 
-        WhereClause.new(parts, binds)
+        WhereClause.new(parts, binds || [])
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :klass, :predicate_builder
+        attr_reader :klass, :predicate_builder
+
+      private
+
+        def perform_case_sensitive?(options)
+          options && options.key?(:case_sensitive)
+        end
+
+        def build_for_case_sensitive(attributes, options)
+          parts, binds = [], []
+          table = klass.arel_table
+
+          attributes.each do |attribute, value|
+            if reflection = klass._reflect_on_association(attribute)
+              attribute = reflection.foreign_key.to_s
+              value = value[reflection.klass.primary_key] unless value.nil?
+            end
+
+            if value.nil?
+              parts << table[attribute].eq(value)
+            else
+              column = klass.column_for_attribute(attribute)
+
+              binds << predicate_builder.send(:build_bind_param, attribute, value)
+              value = Arel::Nodes::BindParam.new
+
+              predicate = if options[:case_sensitive]
+                klass.connection.case_sensitive_comparison(table, attribute, column, value)
+              else
+                klass.connection.case_insensitive_comparison(table, attribute, column, value)
+              end
+
+              parts << predicate
+            end
+          end
+
+          [parts, binds]
+        end
     end
   end
 end

data/lib/active_record/relation.rb

@@ -1,5 +1,3 @@
-require "arel/collectors/bind"
-
 module ActiveRecord
   # = Active Record \Relation
   class Relation
@@ -31,9 +29,7 @@ module ActiveRecord
     end
 
     def initialize_copy(other)
-      # This method is a hot spot, so for now, use Hash[] to dup the hash.
-      #   https://bugs.ruby-lang.org/issues/7166
-      @values        = Hash[@values]
+      @values = @values.dup
       reset
     end
 
@@ -64,14 +60,14 @@ module ActiveRecord
 
       @klass.connection.insert(
         im,
-        'SQL',
-        primary_key,
+        "SQL",
+        primary_key || false,
         primary_key_value,
         nil,
         binds)
     end
 
-    def _update_record(values, id, id_was) # :nodoc:
+    def _update_record(values, constraints) # :nodoc:
       substitutes, binds = substitute_values values
 
       scope = @klass.unscoped
@@ -80,7 +76,7 @@ module ActiveRecord
         scope.unscope!(where: @klass.inheritance_column)
       end
 
-      relation = scope.where(@klass.primary_key => (id_was || id))
+      relation = scope.where(constraints)
       bvs = binds + relation.bound_attributes
       um = relation
         .arel
@@ -88,7 +84,7 @@ module ActiveRecord
 
       @klass.connection.update(
         um,
-        'SQL',
+        "SQL",
         bvs,
       )
     end
@@ -247,7 +243,6 @@ module ActiveRecord
     # Please see further details in the
     # {Active Record Query Interface guide}[http://guides.rubyonrails.org/active_record_querying.html#running-explain].
     def explain
-      #TODO: Fix for binds.
       exec_explain(collecting_queries_for_explain { exec_queries })
     end
 
@@ -266,10 +261,6 @@ module ActiveRecord
       coder.represent_seq(nil, records)
     end
 
-    def as_json(options = nil) #:nodoc:
-      records.as_json(options)
-    end
-
     # Returns size of the records.
     def size
       loaded? ? @records.length : count(:all)
@@ -278,13 +269,7 @@ module ActiveRecord
     # Returns true if there are no records.
     def empty?
       return @records.empty? if loaded?
-
-      if limit_value == 0
-        true
-      else
-        c = count(:all)
-        c.respond_to?(:zero?) ? c.zero? : c.empty?
-      end
+      !exists?
     end
 
     # Returns true if there are no records.
@@ -383,7 +368,7 @@ module ActiveRecord
       stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
       stmt.table(table)
 
-      if joins_values.any?
+      if has_join_values?
         @klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
       else
         stmt.key = arel_attribute(primary_key)
@@ -392,7 +377,7 @@ module ActiveRecord
         stmt.wheres = arel.constraints
       end
 
-      @klass.connection.update stmt, 'SQL', bound_attributes
+      @klass.connection.update stmt, "SQL", bound_attributes
     end
 
     # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -428,8 +413,7 @@ module ActiveRecord
         records.each { |record| record.update(attributes) }
       else
         if ActiveRecord::Base === id
-          id = id.id
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          raise ArgumentError, <<-MSG.squish
             You are passing an instance of ActiveRecord::Base to `update`.
             Please pass the id of the object by calling `.id`.
           MSG
@@ -456,16 +440,8 @@ module ActiveRecord
     # ==== Examples
     #
     #   Person.where(age: 0..18).destroy_all
-    def destroy_all(conditions = nil)
-      if conditions
-        ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
-          Passing conditions to destroy_all is deprecated and will be removed in Rails 5.1.
-          To achieve the same use where(conditions).destroy_all.
-        MESSAGE
-        where(conditions).destroy_all
-      else
-        records.each(&:destroy).tap { reset }
-      end
+    def destroy_all
+      records.each(&:destroy).tap { reset }
     end
 
     # Destroy an object (or multiple objects) that has the given id. The object is instantiated first,
@@ -513,41 +489,28 @@ module ActiveRecord
     #
     #   Post.limit(100).delete_all
     #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit
-    def delete_all(conditions = nil)
-      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select { |method|
-        if MULTI_VALUE_METHODS.include?(method)
-          send("#{method}_values").any?
-        elsif SINGLE_VALUE_METHODS.include?(method)
-          send("#{method}_value")
-        elsif CLAUSE_METHODS.include?(method)
-          send("#{method}_clause").any?
-        end
-      }
+    def delete_all
+      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
+        value = get_value(method)
+        SINGLE_VALUE_METHODS.include?(method) ? value : value.any?
+      end
       if invalid_methods.any?
         raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
       end
 
-      if conditions
-        ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
-          Passing conditions to delete_all is deprecated and will be removed in Rails 5.1.
-          To achieve the same use where(conditions).delete_all.
-        MESSAGE
-        where(conditions).delete_all
-      else
-        stmt = Arel::DeleteManager.new
-        stmt.from(table)
+      stmt = Arel::DeleteManager.new
+      stmt.from(table)
 
-        if joins_values.any?
-          @klass.connection.join_to_delete(stmt, arel, arel_attribute(primary_key))
-        else
-          stmt.wheres = arel.constraints
-        end
+      if has_join_values?
+        @klass.connection.join_to_delete(stmt, arel, arel_attribute(primary_key))
+      else
+        stmt.wheres = arel.constraints
+      end
 
-        affected = @klass.connection.delete(stmt, 'SQL', bound_attributes)
+      affected = @klass.connection.delete(stmt, "SQL", bound_attributes)
 
-        reset
-        affected
-      end
+      reset
+      affected
     end
 
     # Deletes the row with a primary key matching the +id+ argument, using a
@@ -605,19 +568,16 @@ module ActiveRecord
     #   # => SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'
     def to_sql
       @to_sql ||= begin
-                    relation   = self
-                    connection = klass.connection
-                    visitor    = connection.visitor
+                    relation = self
 
                     if eager_loading?
-                      find_with_associations { |rel| relation = rel }
+                      find_with_associations { |rel, _| relation = rel }
                     end
 
-                    binds = relation.bound_attributes
-                    binds = connection.prepare_binds_for_database(binds)
-                    binds.map! { |value| connection.quote(value) }
-                    collect = visitor.accept(relation.arel.ast, Arel::Collectors::Bind.new)
-                    collect.substitute_binds(binds).join
+                    conn = klass.connection
+                    conn.unprepared_statement {
+                      conn.to_sql(relation.arel, relation.bound_attributes)
+                    }
                   end
     end
 
@@ -648,15 +608,6 @@ module ActiveRecord
       includes_values & joins_values
     end
 
-    # {#uniq}[rdoc-ref:QueryMethods#uniq] and
-    # {#uniq!}[rdoc-ref:QueryMethods#uniq!] are silently deprecated.
-    # #uniq_value delegates to #distinct_value to maintain backwards compatibility.
-    # Use #distinct_value instead.
-    def uniq_value
-      distinct_value
-    end
-    deprecate uniq_value: :distinct_value
-
     # Compares two relations for equality.
     def ==(other)
       case other
@@ -670,7 +621,7 @@ module ActiveRecord
     end
 
     def pretty_print(q)
-      q.pp(self.records)
+      q.pp(records)
     end
 
     # Returns true if relation is blank.
@@ -679,12 +630,14 @@ module ActiveRecord
     end
 
     def values
-      Hash[@values]
+      @values.dup
     end
 
     def inspect
-      entries = records.take([limit_value, 11].compact.min).map!(&:inspect)
-      entries[10] = '...' if entries.size == 11
+      subject = loaded? ? records : self
+      entries = subject.take([limit_value, 11].compact.min).map!(&:inspect)
+
+      entries[10] = "..." if entries.size == 11
 
       "#<#{self.class.name} [#{entries.join(', ')}]>"
     end
@@ -693,6 +646,10 @@ module ActiveRecord
       @values == klass.unscoped.values
     end
 
+    def has_limit_or_offset? # :nodoc:
+      limit_value || offset_value
+    end
+
     protected
 
       def load_records(records)
@@ -702,48 +659,65 @@ module ActiveRecord
 
     private
 
-    def exec_queries(&block)
-      @records = eager_loading? ? find_with_associations.freeze : @klass.find_by_sql(arel, bound_attributes, &block).freeze
-
-      preload = preload_values
-      preload +=  includes_values unless eager_loading?
-      preloader = build_preloader
-      preload.each do |associations|
-        preloader.preload @records, associations
+      def has_join_values?
+        joins_values.any? || left_outer_joins_values.any?
       end
 
-      @records.each(&:readonly!) if readonly_value
+      def exec_queries(&block)
+        @records =
+          if eager_loading?
+            find_with_associations do |relation, join_dependency|
+              if ActiveRecord::NullRelation === relation
+                []
+              else
+                rows = connection.select_all(relation.arel, "SQL", relation.bound_attributes)
+                join_dependency.instantiate(rows, &block)
+              end.freeze
+            end
+          else
+            klass.find_by_sql(arel, bound_attributes, &block).freeze
+          end
+
+        preload = preload_values
+        preload += includes_values unless eager_loading?
+        preloader = nil
+        preload.each do |associations|
+          preloader ||= build_preloader
+          preloader.preload @records, associations
+        end
 
-      @loaded = true
-      @records
-    end
+        @records.each(&:readonly!) if readonly_value
 
-    def build_preloader
-      ActiveRecord::Associations::Preloader.new
-    end
+        @loaded = true
+        @records
+      end
 
-    def references_eager_loaded_tables?
-      joined_tables = arel.join_sources.map do |join|
-        if join.is_a?(Arel::Nodes::StringJoin)
-          tables_in_string(join.left)
-        else
-          [join.left.table_name, join.left.table_alias]
-        end
+      def build_preloader
+        ActiveRecord::Associations::Preloader.new
       end
 
-      joined_tables += [table.name, table.table_alias]
+      def references_eager_loaded_tables?
+        joined_tables = arel.join_sources.map do |join|
+          if join.is_a?(Arel::Nodes::StringJoin)
+            tables_in_string(join.left)
+          else
+            [join.left.table_name, join.left.table_alias]
+          end
+        end
 
-      # always convert table names to downcase as in Oracle quoted table names are in uppercase
-      joined_tables = joined_tables.flatten.compact.map(&:downcase).uniq
+        joined_tables += [table.name, table.table_alias]
 
-      (references_values - joined_tables).any?
-    end
+        # always convert table names to downcase as in Oracle quoted table names are in uppercase
+        joined_tables = joined_tables.flatten.compact.map(&:downcase).uniq
 
-    def tables_in_string(string)
-      return [] if string.blank?
-      # always convert table names to downcase as in Oracle quoted table names are in uppercase
-      # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
-      string.scan(/([a-zA-Z_][.\w]+).?\./).flatten.map(&:downcase).uniq - ['raw_sql_']
-    end
+        (references_values - joined_tables).any?
+      end
+
+      def tables_in_string(string)
+        return [] if string.blank?
+        # always convert table names to downcase as in Oracle quoted table names are in uppercase
+        # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
+        string.scan(/([a-zA-Z_][.\w]+).?\./).flatten.map(&:downcase).uniq - ["raw_sql_"]
+      end
   end
 end