activerecord 1.0.0 → 4.0.0

data/lib/active_record/relation/finder_methods.rb

@@ -0,0 +1,349 @@
+module ActiveRecord
+  module FinderMethods
+    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    # If no record can be found for all of the listed ids, then RecordNotFound will be raised. If the primary key
+    # is an integer, find by id coerces its arguments using +to_i+.
+    #
+    #   Person.find(1)       # returns the object for ID = 1
+    #   Person.find("1")     # returns the object for ID = 1
+    #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
+    #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
+    #   Person.find([1])     # returns an array for the object with ID = 1
+    #   Person.where("administrator = 1").order("created_on DESC").find(1)
+    #
+    # Note that returned records may not be in the same order as the ids you
+    # provide since database rows are unordered. Give an explicit <tt>order</tt>
+    # to ensure the results are sorted.
+    #
+    # ==== Find with lock
+    #
+    # Example for find with a lock: Imagine two concurrent transactions:
+    # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
+    # in two saves of <tt>person.visits = 3</tt>. By locking the row, the second
+    # transaction has to wait until the first is finished; we get the
+    # expected <tt>person.visits == 4</tt>.
+    #
+    #   Person.transaction do
+    #     person = Person.lock(true).find(1)
+    #     person.visits += 1
+    #     person.save!
+    #   end
+    def find(*args)
+      if block_given?
+        to_a.find { |*block_args| yield(*block_args) }
+      else
+        find_with_ids(*args)
+      end
+    end
+
+    # Finds the first record matching the specified conditions. There
+    # is no implied ordering so if order matters, you should specify it
+    # yourself.
+    #
+    # If no record is found, returns <tt>nil</tt>.
+    #
+    #   Post.find_by name: 'Spartacus', rating: 4
+    #   Post.find_by "published_at < ?", 2.weeks.ago
+    def find_by(*args)
+      where(*args).take
+    end
+
+    # Like <tt>find_by</tt>, except that if no record is found, raises
+    # an <tt>ActiveRecord::RecordNotFound</tt> error.
+    def find_by!(*args)
+      where(*args).take!
+    end
+
+    # Gives a record (or N records if a parameter is supplied) without any implied
+    # order. The order will depend on the database implementation.
+    # If an order is supplied it will be respected.
+    #
+    #   Person.take # returns an object fetched by SELECT * FROM people LIMIT 1
+    #   Person.take(5) # returns 5 objects fetched by SELECT * FROM people LIMIT 5
+    #   Person.where(["name LIKE '%?'", name]).take
+    def take(limit = nil)
+      limit ? limit(limit).to_a : find_take
+    end
+
+    # Same as +take+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>take!</tt> accepts no arguments.
+    def take!
+      take or raise RecordNotFound
+    end
+
+    # Find the first record (or first N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).first
+    #   Person.where(["user_name = :u", { u: user_name }]).first
+    #   Person.order("created_on DESC").offset(5).first
+    #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3
+    def first(limit = nil)
+      if limit
+        if order_values.empty? && primary_key
+          order(arel_table[primary_key].asc).limit(limit).to_a
+        else
+          limit(limit).to_a
+        end
+      else
+        find_first
+      end
+    end
+
+    # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>first!</tt> accepts no arguments.
+    def first!
+      first or raise RecordNotFound
+    end
+
+    # Find the last record (or last N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.last # returns the last object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).last
+    #   Person.order("created_on DESC").offset(5).last
+    #   Person.last(3) # returns the last three objects fetched by SELECT * FROM people.
+    #
+    # Take note that in that last case, the results are sorted in ascending order:
+    #
+    #   [#<Person id:2>, #<Person id:3>, #<Person id:4>]
+    #
+    # and not:
+    #
+    #   [#<Person id:4>, #<Person id:3>, #<Person id:2>]
+    def last(limit = nil)
+      if limit
+        if order_values.empty? && primary_key
+          order(arel_table[primary_key].desc).limit(limit).reverse
+        else
+          to_a.last(limit)
+        end
+      else
+        find_last
+      end
+    end
+
+    # Same as +last+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>last!</tt> accepts no arguments.
+    def last!
+      last or raise RecordNotFound
+    end
+
+    # Returns truthy if a record exists in the table that matches the +id+ or
+    # conditions given, or falsy otherwise. The argument can take six forms:
+    #
+    # * Integer - Finds the record with this primary key.
+    # * String - Finds the record with a primary key corresponding to this
+    #   string (such as <tt>'5'</tt>).
+    # * Array - Finds the record that matches these +find+-style conditions
+    #   (such as <tt>['color = ?', 'red']</tt>).
+    # * Hash - Finds the record that matches these +find+-style conditions
+    #   (such as <tt>{color: 'red'}</tt>).
+    # * +false+ - Returns always +false+.
+    # * No args - Returns +false+ if the table is empty, +true+ otherwise.
+    #
+    # For more information about specifying conditions as a Hash or Array,
+    # see the Conditions section in the introduction to ActiveRecord::Base.
+    #
+    # Note: You can't pass in a condition as a string (like <tt>name =
+    # 'Jamie'</tt>), since it would be sanitized and then queried against
+    # the primary key column, like <tt>id = 'name = \'Jamie\''</tt>.
+    #
+    #   Person.exists?(5)
+    #   Person.exists?('5')
+    #   Person.exists?(['name LIKE ?', "%#{query}%"])
+    #   Person.exists?(name: 'David')
+    #   Person.exists?(false)
+    #   Person.exists?
+    def exists?(conditions = :none)
+      conditions = conditions.id if Base === conditions
+      return false if !conditions
+
+      join_dependency = construct_join_dependency_for_association_find
+      relation = construct_relation_for_association_find(join_dependency)
+      relation = relation.except(:select, :order).select("1 AS one").limit(1)
+
+      case conditions
+      when Array, Hash
+        relation = relation.where(conditions)
+      else
+        relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
+      end
+
+      connection.select_value(relation, "#{name} Exists", relation.bind_values)
+    rescue ThrowResult
+      false
+    end
+
+    # This method is called whenever no records are found with either a single
+    # id or multiple ids and raises a +ActiveRecord::RecordNotFound+ exception.
+    #
+    # The error message is different depending on whether a single id or
+    # multiple ids are provided. If multiple ids are provided, then the number
+    # of results obtained should be provided in the +result_size+ argument and
+    # the expected number of results should be provided in the +expected_size+
+    # argument.
+    def raise_record_not_found_exception!(ids, result_size, expected_size) #:nodoc:
+      conditions = arel.where_sql
+      conditions = " [#{conditions}]" if conditions
+
+      if Array(ids).size == 1
+        error = "Couldn't find #{@klass.name} with #{primary_key}=#{ids}#{conditions}"
+      else
+        error = "Couldn't find all #{@klass.name.pluralize} with IDs "
+        error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})"
+      end
+
+      raise RecordNotFound, error
+    end
+
+    protected
+
+    def find_with_associations
+      join_dependency = construct_join_dependency_for_association_find
+      relation = construct_relation_for_association_find(join_dependency)
+      rows = connection.select_all(relation, 'SQL', relation.bind_values.dup)
+      join_dependency.instantiate(rows)
+    rescue ThrowResult
+      []
+    end
+
+    def construct_join_dependency_for_association_find
+      including = (eager_load_values + includes_values).uniq
+      ActiveRecord::Associations::JoinDependency.new(@klass, including, [])
+    end
+
+    def construct_relation_for_association_calculations
+      including = (eager_load_values + includes_values).uniq
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, including, arel.froms.first)
+      relation = except(:includes, :eager_load, :preload)
+      apply_join_dependency(relation, join_dependency)
+    end
+
+    def construct_relation_for_association_find(join_dependency)
+      relation = except(:includes, :eager_load, :preload, :select).select(join_dependency.columns)
+      apply_join_dependency(relation, join_dependency)
+    end
+
+    def apply_join_dependency(relation, join_dependency)
+      join_dependency.join_associations.each do |association|
+        relation = association.join_relation(relation)
+      end
+
+      limitable_reflections = using_limitable_reflections?(join_dependency.reflections)
+
+      if !limitable_reflections && relation.limit_value
+        limited_id_condition = construct_limited_ids_condition(relation.except(:select))
+        relation = relation.where(limited_id_condition)
+      end
+
+      relation = relation.except(:limit, :offset) unless limitable_reflections
+
+      relation
+    end
+
+    def construct_limited_ids_condition(relation)
+      orders = relation.order_values.map { |val| val.presence }.compact
+      values = @klass.connection.distinct("#{quoted_table_name}.#{primary_key}", orders)
+
+      relation = relation.dup.select(values)
+
+      id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
+      ids_array = id_rows.map {|row| row[primary_key]}
+
+      ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
+    end
+
+    def find_with_ids(*ids)
+      expects_array = ids.first.kind_of?(Array)
+      return ids.first if expects_array && ids.first.empty?
+
+      ids = ids.flatten.compact.uniq
+
+      case ids.size
+      when 0
+        raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+      when 1
+        result = find_one(ids.first)
+        expects_array ? [ result ] : result
+      else
+        find_some(ids)
+      end
+    end
+
+    def find_one(id)
+      id = id.id if ActiveRecord::Base === id
+
+      column = columns_hash[primary_key]
+      substitute = connection.substitute_at(column, bind_values.length)
+      relation = where(table[primary_key].eq(substitute))
+      relation.bind_values += [[column, id]]
+      record = relation.take
+
+      raise_record_not_found_exception!(id, 0, 1) unless record
+
+      record
+    end
+
+    def find_some(ids)
+      result = where(table[primary_key].in(ids)).to_a
+
+      expected_size =
+        if limit_value && ids.size > limit_value
+          limit_value
+        else
+          ids.size
+        end
+
+      # 11 ids with limit 3, offset 9 should give 2 results.
+      if offset_value && (ids.size - offset_value < expected_size)
+        expected_size = ids.size - offset_value
+      end
+
+      if result.size == expected_size
+        result
+      else
+        raise_record_not_found_exception!(ids, result.size, expected_size)
+      end
+    end
+
+    def find_take
+      if loaded?
+        @records.first
+      else
+        @take ||= limit(1).to_a.first
+      end
+    end
+
+    def find_first
+      if loaded?
+        @records.first
+      else
+        @first ||=
+          if with_default_scope.order_values.empty? && primary_key
+            order(arel_table[primary_key].asc).limit(1).to_a.first
+          else
+            limit(1).to_a.first
+          end
+      end
+    end
+
+    def find_last
+      if loaded?
+        @records.last
+      else
+        @last ||=
+          if offset_value || limit_value
+            to_a.last
+          else
+            reverse_order.limit(1).to_a.first
+          end
+      end
+    end
+
+    def using_limitable_reflections?(reflections)
+      reflections.none? { |r| r.collection? }
+    end
+  end
+end

data/lib/active_record/relation/merger.rb

@@ -0,0 +1,161 @@
+require 'active_support/core_ext/hash/keys'
+require "set"
+
+module ActiveRecord
+  class Relation
+    class HashMerger # :nodoc:
+      attr_reader :relation, :hash
+
+      def initialize(relation, hash)
+        hash.assert_valid_keys(*Relation::VALUE_METHODS)
+
+        @relation = relation
+        @hash     = hash
+      end
+
+      def merge
+        Merger.new(relation, other).merge
+      end
+
+      # Applying values to a relation has some side effects. E.g.
+      # interpolation might take place for where values. So we should
+      # build a relation to merge in rather than directly merging
+      # the values.
+      def other
+        other = Relation.new(relation.klass, relation.table)
+        hash.each { |k, v|
+          if k == :joins
+            if Hash === v
+              other.joins!(v)
+            else
+              other.joins!(*v)
+            end
+          else
+            other.send("#{k}!", v)
+          end
+        }
+        other
+      end
+    end
+
+    class Merger # :nodoc:
+      attr_reader :relation, :values, :other
+
+      def initialize(relation, other)
+        if other.default_scoped? && other.klass != relation.klass
+          other = other.with_default_scope
+        end
+
+        @relation = relation
+        @values   = other.values
+        @other    = other
+      end
+
+      NORMAL_VALUES = Relation::SINGLE_VALUE_METHODS +
+                      Relation::MULTI_VALUE_METHODS -
+                      [:joins, :where, :order, :bind, :reverse_order, :lock, :create_with, :reordering, :from] # :nodoc:
+
+      def normal_values
+        NORMAL_VALUES
+      end
+
+      def merge
+        normal_values.each do |name|
+          value = values[name]
+          relation.send("#{name}!", *value) unless value.blank?
+        end
+
+        merge_multi_values
+        merge_single_values
+        merge_joins
+
+        relation
+      end
+
+      private
+
+      def merge_joins
+        return if values[:joins].blank?
+
+        if other.klass == relation.klass
+          relation.joins!(*values[:joins])
+        else
+          joins_dependency, rest = values[:joins].partition do |join|
+            case join
+            when Hash, Symbol, Array
+              true
+            else
+              false
+            end
+          end
+
+          join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
+                                                                           joins_dependency,
+                                                                           [])
+          relation.joins! rest
+
+          join_dependency.join_associations.each do |association|
+            @relation = association.join_relation(relation)
+          end
+        end
+      end
+
+      def merge_multi_values
+        relation.where_values = merged_wheres
+        relation.bind_values  = merged_binds
+
+        if values[:reordering]
+          # override any order specified in the original relation
+          relation.reorder! values[:order]
+        elsif values[:order]
+          # merge in order_values from r
+          relation.order! values[:order]
+        end
+
+        relation.extend(*values[:extending]) unless values[:extending].blank?
+      end
+
+      def merge_single_values
+        relation.from_value          = values[:from] unless relation.from_value
+        relation.lock_value          = values[:lock] unless relation.lock_value
+        relation.reverse_order_value = values[:reverse_order]
+
+        unless values[:create_with].blank?
+          relation.create_with_value = (relation.create_with_value || {}).merge(values[:create_with])
+        end
+      end
+
+      def merged_binds
+        if values[:bind]
+          (relation.bind_values + values[:bind]).uniq(&:first)
+        else
+          relation.bind_values
+        end
+      end
+
+      def merged_wheres
+        values[:where] ||= []
+
+        if values[:where].empty? || relation.where_values.empty?
+          relation.where_values + values[:where]
+        else
+          # Remove equalities from the existing relation with a LHS which is
+          # present in the relation being merged in.
+
+          seen = Set.new
+          values[:where].each { |w|
+            if w.respond_to?(:operator) && w.operator == :==
+              seen << w.left
+            end
+          }
+
+          relation.where_values.reject { |w|
+            w.respond_to?(:operator) &&
+              w.operator == :== &&
+              seen.include?(w.left)
+          } + values[:where]
+        end
+      end
+    end
+  end
+end

data/lib/active_record/relation/predicate_builder.rb

@@ -0,0 +1,106 @@
+module ActiveRecord
+  class PredicateBuilder # :nodoc:
+    def self.build_from_hash(klass, attributes, default_table)
+      queries = []
+
+      attributes.each do |column, value|
+        table = default_table
+
+        if value.is_a?(Hash)
+          if value.empty?
+            queries << '1=0'
+          else
+            table       = Arel::Table.new(column, default_table.engine)
+            association = klass.reflect_on_association(column.to_sym)
+
+            value.each do |k, v|
+              queries.concat expand(association && association.klass, table, k, v)
+            end
+          end
+        else
+          column = column.to_s
+
+          if column.include?('.')
+            table_name, column = column.split('.', 2)
+            table = Arel::Table.new(table_name, default_table.engine)
+          end
+
+          queries.concat expand(klass, table, column, value)
+        end
+      end
+
+      queries
+    end
+
+    def self.expand(klass, table, column, value)
+      queries = []
+
+      # Find the foreign key when using queries such as:
+      # Post.where(author: author)
+      #
+      # For polymorphic relationships, find the foreign key and type:
+      # PriceEstimate.where(estimate_of: treasure)
+      if klass && value.class < Base && reflection = klass.reflect_on_association(column.to_sym)
+        if reflection.polymorphic?
+          queries << build(table[reflection.foreign_type], value.class.base_class)
+        end
+
+        column = reflection.foreign_key
+      end
+
+      queries << build(table[column], value)
+      queries
+    end
+
+    def self.references(attributes)
+      attributes.map do |key, value|
+        if value.is_a?(Hash)
+          key
+        else
+          key = key.to_s
+          key.split('.').first if key.include?('.')
+        end
+      end.compact
+    end
+
+    private
+      def self.build(attribute, value)
+        case value
+        when Array
+          values = value.to_a.map {|x| x.is_a?(Base) ? x.id : x}
+          ranges, values = values.partition {|v| v.is_a?(Range)}
+
+          values_predicate = if values.include?(nil)
+            values = values.compact
+
+            case values.length
+            when 0
+              attribute.eq(nil)
+            when 1
+              attribute.eq(values.first).or(attribute.eq(nil))
+            else
+              attribute.in(values).or(attribute.eq(nil))
+            end
+          else
+            attribute.in(values)
+          end
+
+          array_predicates = ranges.map { |range| attribute.in(range) }
+          array_predicates << values_predicate
+          array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        when ActiveRecord::Relation
+          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+          attribute.in(value.arel.ast)
+        when Range
+          attribute.in(value)
+        when ActiveRecord::Base
+          attribute.eq(value.id)
+        when Class
+          # FIXME: I think we need to deprecate this behavior
+          attribute.eq(value.name)
+        else
+          attribute.eq(value)
+        end
+      end
+  end
+end