activerecord 4.2.11.1 → 5.0.0

data/lib/active_record/relation/record_fetch_warning.rb

@@ -0,0 +1,49 @@
+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
+      # set to an integer, if the number of records a query returns is
+      # 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.
+      def exec_queries
+        QueryRegistry.reset
+
+        super.tap do
+          if logger && warn_on_records_fetched_greater_than
+            if @records.length > warn_on_records_fetched_greater_than
+              logger.warn "Query fetched #{@records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
+            end
+          end
+        end
+      end
+
+      # :stopdoc:
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+        QueryRegistry.queries << payload[:sql]
+      end
+      # :startdoc:
+
+      class QueryRegistry # :nodoc:
+        extend ActiveSupport::PerThreadRegistry
+
+        attr_reader :queries
+
+        def initialize
+          @queries = []
+        end
+
+        def reset
+          @queries.clear
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend ActiveRecord::Relation::RecordFetchWarning

data/lib/active_record/relation/spawn_methods.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       clone
     end
 
-    # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an <tt>ActiveRecord::Relation</tt>.
+    # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an ActiveRecord::Relation.
     # Returns an array representing the intersection of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
     #
     #   Post.where(published: true).joins(:comments).merge( Comment.where(spam: false) )
@@ -29,11 +29,11 @@ module ActiveRecord
     # This is mainly intended for sharing common conditions between multiple associations.
     def merge(other)
       if other.is_a?(Array)
-        to_a & other
+        records & other
       elsif other
         spawn.merge!(other)
       else
-        self
+        raise ArgumentError, "invalid argument: #{other.inspect}."
       end
     end
 
@@ -62,16 +62,13 @@ module ActiveRecord
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     def only(*onlies)
-      if onlies.any? { |o| o == :where }
-        onlies << :bind
-      end
       relation_with values.slice(*onlies)
     end
 
     private
 
       def relation_with(values) # :nodoc:
-        result = Relation.create(klass, table, values)
+        result = Relation.create(klass, table, predicate_builder, values)
         result.extend(*extending_values) if extending_values.any?
         result
       end

data/lib/active_record/relation/where_clause.rb

@@ -0,0 +1,174 @@
+module ActiveRecord
+  class Relation
+    class WhereClause # :nodoc:
+      attr_reader :binds
+
+      delegate :any?, :empty?, to: :predicates
+
+      def initialize(predicates, binds)
+        @predicates = predicates
+        @binds = binds
+      end
+
+      def +(other)
+        WhereClause.new(
+          predicates + other.predicates,
+          binds + other.binds,
+        )
+      end
+
+      def merge(other)
+        WhereClause.new(
+          predicates_unreferenced_by(other) + other.predicates,
+          non_conflicting_binds(other) + other.binds,
+        )
+      end
+
+      def except(*columns)
+        WhereClause.new(
+          predicates_except(columns),
+          binds_except(columns),
+        )
+      end
+
+      def or(other)
+        if empty?
+          self
+        elsif other.empty?
+          other
+        else
+          WhereClause.new(
+            [ast.or(other.ast)],
+            binds + other.binds
+          )
+        end
+      end
+
+      def to_h(table_name = nil)
+        equalities = predicates.grep(Arel::Nodes::Equality)
+        if table_name
+          equalities = equalities.select do |node|
+            node.left.relation.name == table_name
+          end
+        end
+
+        binds = self.binds.map { |attr| [attr.name, attr.value] }.to_h
+
+        equalities.map { |node|
+          name = node.left.name
+          [name, binds.fetch(name.to_s) {
+            case node.right
+            when Array then node.right.map(&:val)
+            when Arel::Nodes::Casted, Arel::Nodes::Quoted
+              node.right.val
+            end
+          }]
+        }.to_h
+      end
+
+      def ast
+        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+      end
+
+      def ==(other)
+        other.is_a?(WhereClause) &&
+          predicates == other.predicates &&
+          binds == other.binds
+      end
+
+      def invert
+        WhereClause.new(inverted_predicates, binds)
+      end
+
+      def self.empty
+        @empty ||= new([], [])
+      end
+
+      protected
+
+      attr_reader :predicates
+
+      def referenced_columns
+        @referenced_columns ||= begin
+          equality_nodes = predicates.select { |n| equality_node?(n) }
+          Set.new(equality_nodes, &:left)
+        end
+      end
+
+      private
+
+      def predicates_unreferenced_by(other)
+        predicates.reject do |n|
+          equality_node?(n) && other.referenced_columns.include?(n.left)
+        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 inverted_predicates
+        predicates.map { |node| invert_predicate(node) }
+      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)
+        end
+      end
+
+      def predicates_except(columns)
+        predicates.reject do |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)
+          end
+        end
+      end
+
+      def binds_except(columns)
+        binds.reject do |attr|
+          columns.include?(attr.name)
+        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)
+          end
+        end
+      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)
+        end
+        Arel::Nodes::Grouping.new(node)
+      end
+    end
+  end
+end

data/lib/active_record/relation/where_clause_factory.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  class Relation
+    class WhereClauseFactory # :nodoc:
+      def initialize(klass, predicate_builder)
+        @klass = klass
+        @predicate_builder = predicate_builder
+      end
+
+      def build(opts, other)
+        binds = []
+
+        case opts
+        when String, Array
+          parts = [klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
+        when Hash
+          attributes = predicate_builder.resolve_column_aliases(opts)
+          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)
+        when Arel::Nodes::Node
+          parts = [opts]
+          binds = other
+        else
+          raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
+        end
+
+        WhereClause.new(parts, binds)
+      end
+
+      protected
+
+      attr_reader :klass, :predicate_builder
+    end
+  end
+end

data/lib/active_record/result.rb

@@ -1,7 +1,8 @@
 module ActiveRecord
   ###
-  # This class encapsulates a Result returned from calling +exec_query+ on any
-  # database connection adapter. For example:
+  # This class encapsulates a result returned from calling
+  # {#exec_query}[rdoc-ref:ConnectionAdapters::DatabaseStatements#exec_query]
+  # on any database connection adapter. For example:
   #
   #   result = ActiveRecord::Base.connection.exec_query('SELECT id, title, body FROM posts')
   #   result # => #<ActiveRecord::Result:0xdeadbeef>
@@ -81,7 +82,7 @@ module ActiveRecord
     def cast_values(type_overrides = {}) # :nodoc:
       types = columns.map { |name| column_type(name, type_overrides) }
       result = rows.map do |values|
-        types.zip(values).map { |type, value| type.type_cast_from_database(value) }
+        types.zip(values).map { |type, value| type.deserialize(value) }
       end
 
       columns.one? ? result.map!(&:first) : result

data/lib/active_record/runtime_registry.rb

@@ -7,7 +7,7 @@ module ActiveRecord
   #
   # returns the connection handler local to the current thread.
   #
-  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
+  # See the documentation of ActiveSupport::PerThreadRegistry
   # for further details.
   class RuntimeRegistry # :nodoc:
     extend ActiveSupport::PerThreadRegistry

data/lib/active_record/sanitization.rb

@@ -3,28 +3,34 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def quote_value(value, column) #:nodoc:
-        connection.quote(value, column)
-      end
-
-      # Used to sanitize objects before they're used in an SQL SELECT statement. Delegates to <tt>connection.quote</tt>.
-      def sanitize(object) #:nodoc:
+      # Used to sanitize objects before they're used in an SQL SELECT statement.
+      # Delegates to {connection.quote}[rdoc-ref:ConnectionAdapters::Quoting#quote].
+      def sanitize(object) # :nodoc:
         connection.quote(object)
       end
+      alias_method :quote_value, :sanitize
 
       protected
 
-      # Accepts an array, hash, or string of SQL conditions and sanitizes
+      # Accepts an array or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a WHERE clause.
-      #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
-      #   { name: "foo'bar", group_id: 4 }  returns "name='foo''bar' and group_id='4'"
-      #   "name='foo''bar' and group_id='4'" returns "name='foo''bar' and group_id='4'"
-      def sanitize_sql_for_conditions(condition, table_name = self.table_name)
+      #
+      #   sanitize_sql_for_conditions(["name=? and group_id=?", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_for_conditions(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      #   sanitize_sql_for_conditions(["name='%s' and group_id='%s'", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      #   sanitize_sql_for_conditions("name='foo''bar' and group_id='4'")
+      #   # => "name='foo''bar' and group_id='4'"
+      def sanitize_sql_for_conditions(condition)
         return nil if condition.blank?
 
         case condition
         when Array; sanitize_sql_array(condition)
-        when Hash;  sanitize_sql_hash_for_conditions(condition, table_name)
         else        condition
         end
       end
@@ -33,7 +39,18 @@ module ActiveRecord
 
       # Accepts an array, hash, or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a SET clause.
-      #   { name: nil, group_id: 4 }  returns "name = NULL , group_id='4'"
+      #
+      #   sanitize_sql_for_assignment(["name=? and group_id=?", nil, 4])
+      #   # => "name=NULL and group_id=4"
+      #
+      #   sanitize_sql_for_assignment(["name=:name and group_id=:group_id", name: nil, group_id: 4])
+      #   # => "name=NULL and group_id=4"
+      #
+      #   Post.send(:sanitize_sql_for_assignment, { name: nil, group_id: 4 })
+      #   # => "`posts`.`name` = NULL, `posts`.`group_id` = 4"
+      #
+      #   sanitize_sql_for_assignment("name=NULL and group_id='4'")
+      #   # => "name=NULL and group_id='4'"
       def sanitize_sql_for_assignment(assignments, default_table_name = self.table_name)
         case assignments
         when Array; sanitize_sql_array(assignments)
@@ -42,17 +59,37 @@ module ActiveRecord
         end
       end
 
+      # Accepts an array, or string of SQL conditions and sanitizes
+      # them into a valid SQL fragment for an ORDER clause.
+      #
+      #   sanitize_sql_for_order(["field(id, ?)", [1,3,2]])
+      #   # => "field(id, 1,3,2)"
+      #
+      #   sanitize_sql_for_order("id ASC")
+      #   # => "id ASC"
+      def sanitize_sql_for_order(condition)
+        if condition.is_a?(Array) && condition.first.to_s.include?('?')
+          sanitize_sql_array(condition)
+        else
+          condition
+        end
+      end
+
       # Accepts a hash of SQL conditions and replaces those attributes
-      # that correspond to a +composed_of+ relationship with their expanded
-      # aggregate attribute values.
+      # that correspond to a {#composed_of}[rdoc-ref:Aggregations::ClassMethods#composed_of]
+      # relationship with their expanded aggregate attribute values.
+      #
       # Given:
-      #     class Person < ActiveRecord::Base
-      #       composed_of :address, class_name: "Address",
-      #         mapping: [%w(address_street street), %w(address_city city)]
-      #     end
+      #
+      #   class Person < ActiveRecord::Base
+      #     composed_of :address, class_name: "Address",
+      #       mapping: [%w(address_street street), %w(address_city city)]
+      #   end
+      #
       # Then:
-      #     { address: Address.new("813 abc st.", "chicago") }
-      #       # => { address_street: "813 abc st.", address_city: "chicago" }
+      #
+      #   { address: Address.new("813 abc st.", "chicago") }
+      #   # => { address_street: "813 abc st.", address_city: "chicago" }
       def expand_hash_conditions_for_aggregates(attrs)
         expanded_attrs = {}
         attrs.each do |attr, value|
@@ -72,46 +109,32 @@ module ActiveRecord
         expanded_attrs
       end
 
-      # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
-      #   { name: "foo'bar", group_id: 4 }
-      #     # => "name='foo''bar' and group_id= 4"
-      #   { status: nil, group_id: [1,2,3] }
-      #     # => "status IS NULL and group_id IN (1,2,3)"
-      #   { age: 13..18 }
-      #     # => "age BETWEEN 13 AND 18"
-      #   { 'other_records.id' => 7 }
-      #     # => "`other_records`.`id` = 7"
-      #   { other_records: { id: 7 } }
-      #     # => "`other_records`.`id` = 7"
-      # And for value objects on a composed_of relationship:
-      #   { address: Address.new("123 abc st.", "chicago") }
-      #     # => "address_street='123 abc st.' and address_city='chicago'"
-      def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
-        ActiveSupport::Deprecation.warn(<<-EOWARN)
-sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
-        EOWARN
-        attrs = PredicateBuilder.resolve_column_aliases self, attrs
-        attrs = expand_hash_conditions_for_aggregates(attrs)
-
-        table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
-        PredicateBuilder.build_from_hash(self, attrs, table).map { |b|
-          connection.visitor.compile b
-        }.join(' AND ')
-      end
-      alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
-
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
-      #   { status: nil, group_id: 1 }
-      #     # => "status = NULL , group_id = 1"
+      #
+      #   sanitize_sql_hash_for_assignment({ status: nil, group_id: 1 }, "posts")
+      #   # => "`posts`.`status` = NULL, `posts`.`group_id` = 1"
       def sanitize_sql_hash_for_assignment(attrs, table)
         c = connection
         attrs.map do |attr, value|
-          "#{c.quote_table_name_for_assignment(table, attr)} = #{quote_bound_value(value, c, columns_hash[attr.to_s])}"
+          value = type_for_attribute(attr.to_s).serialize(value)
+          "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
         end.join(', ')
       end
 
       # Sanitizes a +string+ so that it is safe to use within an SQL
-      # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%"
+      # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%".
+      #
+      #   sanitize_sql_like("100%")
+      #   # => "100\\%"
+      #
+      #   sanitize_sql_like("snake_cased_string")
+      #   # => "snake\\_cased\\_string"
+      #
+      #   sanitize_sql_like("100%", "!")
+      #   # => "100!%"
+      #
+      #   sanitize_sql_like("snake_cased_string", "!")
+      #   # => "snake!_cased!_string"
       def sanitize_sql_like(string, escape_character = "\\")
         pattern = Regexp.union(escape_character, "%", "_")
         string.gsub(pattern) { |x| [escape_character, x].join }
@@ -119,7 +142,15 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
 
       # Accepts an array of conditions. The array has each value
       # sanitized and interpolated into the SQL statement.
-      #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
+      #
+      #   sanitize_sql_array(["name=? and group_id=?", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_array(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_array(["name='%s' and group_id='%s'", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id='4'"
       def sanitize_sql_array(ary)
         statement, *values = ary
         if values.first.is_a?(Hash) && statement =~ /:\w+/
@@ -133,7 +164,7 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def replace_bind_variables(statement, values) #:nodoc:
+      def replace_bind_variables(statement, values) # :nodoc:
         raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
         bound = values.dup
         c = connection
@@ -142,7 +173,7 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def replace_bind_variable(value, c = connection) #:nodoc:
+      def replace_bind_variable(value, c = connection) # :nodoc:
         if ActiveRecord::Relation === value
           value.to_sql
         else
@@ -150,10 +181,10 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def replace_named_bind_variables(statement, bind_vars) #:nodoc:
-        statement.gsub(/(:?):([a-zA-Z]\w*)/) do
+      def replace_named_bind_variables(statement, bind_vars) # :nodoc:
+        statement.gsub(/(:?):([a-zA-Z]\w*)/) do |match|
           if $1 == ':' # skip postgresql casts
-            $& # return the whole match
+            match # return the whole match
           elsif bind_vars.include?(match = $2.to_sym)
             replace_bind_variable(bind_vars[match])
           else
@@ -162,10 +193,8 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def quote_bound_value(value, c = connection, column = nil) #:nodoc:
-        if column
-          c.quote(value, column)
-        elsif value.respond_to?(:map) && !value.acts_like?(:string)
+      def quote_bound_value(value, c = connection) # :nodoc:
+        if value.respond_to?(:map) && !value.acts_like?(:string)
           if value.respond_to?(:empty?) && value.empty?
             c.quote(nil)
           else
@@ -176,7 +205,7 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def raise_if_bind_arity_mismatch(statement, expected, provided) #:nodoc:
+      def raise_if_bind_arity_mismatch(statement, expected, provided) # :nodoc:
         unless expected == provided
           raise PreparedStatementInvalid, "wrong number of bind variables (#{provided} for #{expected}) in: #{statement}"
         end
@@ -184,8 +213,8 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
     end
 
     # TODO: Deprecate this
-    def quoted_id
-      self.class.quote_value(id, column_for_attribute(self.class.primary_key))
+    def quoted_id # :nodoc:
+      self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
     end
   end
 end