activerecord 2.3.18 → 3.2.22

data/lib/active_record/relation/query_methods.rb

@@ -0,0 +1,417 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  module QueryMethods
+    extend ActiveSupport::Concern
+
+    attr_accessor :includes_values, :eager_load_values, :preload_values,
+                  :select_values, :group_values, :order_values, :joins_values,
+                  :where_values, :having_values, :bind_values,
+                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value,
+                  :from_value, :reordering_value, :reverse_order_value,
+                  :uniq_value
+
+    def includes(*args)
+      args.reject! {|a| a.blank? }
+
+      return self if args.empty?
+
+      relation = clone
+      relation.includes_values = (relation.includes_values + args).flatten.uniq
+      relation
+    end
+
+    def eager_load(*args)
+      return self if args.blank?
+
+      relation = clone
+      relation.eager_load_values += args
+      relation
+    end
+
+    def preload(*args)
+      return self if args.blank?
+
+      relation = clone
+      relation.preload_values += args
+      relation
+    end
+
+    # Works in two unique ways.
+    #
+    # First: takes a block so it can be used just like Array#select.
+    #
+    #   Model.scoped.select { |m| m.field == value }
+    #
+    # This will build an array of objects from the database for the scope,
+    # converting them into an array and iterating through them using Array#select.
+    #
+    # Second: Modifies the SELECT statement for the query so that only certain
+    # fields are retrieved:
+    #
+    #   >> Model.select(:field)
+    #   => [#<Model field:value>]
+    #
+    # Although in the above example it looks as though this method returns an
+    # array, it actually returns a relation object and can have other query
+    # methods appended to it, such as the other methods in ActiveRecord::QueryMethods.
+    #
+    # The argument to the method can also be an array of fields.
+    #
+    #   >> Model.select([:field, :other_field, :and_one_more])
+    #   => [#<Model field: "value", other_field: "value", and_one_more: "value">]
+    #
+    # Any attributes that do not have fields retrieved by a select
+    # will raise a ActiveModel::MissingAttributeError when the getter method for that attribute is used:
+    #
+    #   >> Model.select(:field).first.other_field
+    #   => ActiveModel::MissingAttributeError: missing attribute: other_field
+    def select(value = Proc.new)
+      if block_given?
+        to_a.select {|*block_args| value.call(*block_args) }
+      else
+        relation = clone
+        relation.select_values += Array.wrap(value)
+        relation
+      end
+    end
+
+    def group(*args)
+      return self if args.blank?
+
+      relation = clone
+      relation.group_values += args.flatten
+      relation
+    end
+
+    def order(*args)
+      return self if args.blank?
+
+      relation = clone
+      relation.order_values += args.flatten
+      relation
+    end
+
+    # Replaces any existing order defined on the relation with the specified order.
+    #
+    #   User.order('email DESC').reorder('id ASC') # generated SQL has 'ORDER BY id ASC'
+    #
+    # Subsequent calls to order on the same relation will be appended. For example:
+    #
+    #   User.order('email DESC').reorder('id ASC').order('name ASC')
+    #
+    # generates a query with 'ORDER BY id ASC, name ASC'.
+    #
+    def reorder(*args)
+      return self if args.blank?
+
+      relation = clone
+      relation.reordering_value = true
+      relation.order_values = args.flatten
+      relation
+    end
+
+    def joins(*args)
+      return self if args.compact.blank?
+
+      relation = clone
+
+      args.flatten!
+      relation.joins_values += args
+
+      relation
+    end
+
+    def bind(value)
+      relation = clone
+      relation.bind_values += [value]
+      relation
+    end
+
+    def where(opts, *rest)
+      return self if opts.blank?
+
+      relation = clone
+      relation.where_values += build_where(opts, rest)
+      relation
+    end
+
+    def having(opts, *rest)
+      return self if opts.blank?
+
+      relation = clone
+      relation.having_values += build_where(opts, rest)
+      relation
+    end
+
+    def limit(value)
+      relation = clone
+      relation.limit_value = value
+      relation
+    end
+
+    def offset(value)
+      relation = clone
+      relation.offset_value = value
+      relation
+    end
+
+    def lock(locks = true)
+      relation = clone
+
+      case locks
+      when String, TrueClass, NilClass
+        relation.lock_value = locks || true
+      else
+        relation.lock_value = false
+      end
+
+      relation
+    end
+
+    def readonly(value = true)
+      relation = clone
+      relation.readonly_value = value
+      relation
+    end
+
+    def create_with(value)
+      relation = clone
+      relation.create_with_value = value ? create_with_value.merge(value) : {}
+      relation
+    end
+
+    def from(value)
+      relation = clone
+      relation.from_value = value
+      relation
+    end
+
+    # Specifies whether the records should be unique or not. For example:
+    #
+    #   User.select(:name)
+    #   # => Might return two records with the same name
+    #
+    #   User.select(:name).uniq
+    #   # => Returns 1 record per unique name
+    #
+    #   User.select(:name).uniq.uniq(false)
+    #   # => You can also remove the uniqueness
+    def uniq(value = true)
+      relation = clone
+      relation.uniq_value = value
+      relation
+    end
+
+    # Used to extend a scope with additional methods, either through
+    # a module or through a block provided.
+    #
+    # The object returned is a relation, which can be further extended.
+    #
+    # === Using a module
+    #
+    #   module Pagination
+    #     def page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    #
+    #   scope = Model.scoped.extending(Pagination)
+    #   scope.page(params[:page])
+    #
+    # You can also pass a list of modules:
+    #
+    #   scope = Model.scoped.extending(Pagination, SomethingElse)
+    #
+    # === Using a block
+    #
+    #   scope = Model.scoped.extending do
+    #     def page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    #   scope.page(params[:page])
+    #
+    # You can also use a block and a module list:
+    #
+    #   scope = Model.scoped.extending(Pagination) do
+    #     def per_page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    def extending(*modules)
+      modules << Module.new(&Proc.new) if block_given?
+
+      return self if modules.empty?
+
+      relation = clone
+      relation.send(:apply_modules, modules.flatten)
+      relation
+    end
+
+    def reverse_order
+      relation = clone
+      relation.reverse_order_value = !relation.reverse_order_value
+      relation
+    end
+
+    def arel
+      @arel ||= with_default_scope.build_arel
+    end
+
+    def build_arel
+      arel = table.from table
+
+      build_joins(arel, @joins_values) unless @joins_values.empty?
+
+      collapse_wheres(arel, (@where_values - ['']).uniq)
+
+      arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
+
+      arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
+      arel.skip(@offset_value.to_i) if @offset_value
+
+      arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
+
+      order = @order_values
+      order = reverse_sql_order(order) if @reverse_order_value
+      arel.order(*order.uniq.reject{|o| o.blank?}) unless order.empty?
+
+      build_select(arel, @select_values.uniq)
+
+      arel.distinct(@uniq_value)
+      arel.from(@from_value) if @from_value
+      arel.lock(@lock_value) if @lock_value
+
+      arel
+    end
+
+    private
+
+    def custom_join_ast(table, joins)
+      joins = joins.reject { |join| join.blank? }
+
+      return [] if joins.empty?
+
+      @implicit_readonly = true
+
+      joins.map do |join|
+        case join
+        when Array
+          join = Arel.sql(join.join(' ')) if array_of_strings?(join)
+        when String
+          join = Arel.sql(join)
+        end
+        table.create_string_join(join)
+      end
+    end
+
+    def collapse_wheres(arel, wheres)
+      equalities = wheres.grep(Arel::Nodes::Equality)
+
+      arel.where(Arel::Nodes::And.new(equalities)) unless equalities.empty?
+
+      (wheres - equalities).each do |where|
+        where = Arel.sql(where) if String === where
+        arel.where(Arel::Nodes::Grouping.new(where))
+      end
+    end
+
+    def build_where(opts, other = [])
+      case opts
+      when String, Array
+        [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
+      when Hash
+        attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
+        PredicateBuilder.build_from_hash(table.engine, attributes, table)
+      else
+        [opts]
+      end
+    end
+
+    def build_joins(manager, joins)
+      buckets = joins.group_by do |join|
+        case join
+        when String
+          'string_join'
+        when Hash, Symbol, Array
+          'association_join'
+        when ActiveRecord::Associations::JoinDependency::JoinAssociation
+          'stashed_join'
+        when Arel::Nodes::Join
+          'join_node'
+        else
+          raise 'unknown class: %s' % join.class.name
+        end
+      end
+
+      association_joins         = buckets['association_join'] || []
+      stashed_association_joins = buckets['stashed_join'] || []
+      join_nodes                = (buckets['join_node'] || []).uniq
+      string_joins              = (buckets['string_join'] || []).map { |x|
+        x.strip
+      }.uniq
+
+      join_list = join_nodes + custom_join_ast(manager, string_joins)
+
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(
+        @klass,
+        association_joins,
+        join_list
+      )
+
+      join_dependency.graft(*stashed_association_joins)
+
+      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+
+      # FIXME: refactor this to build an AST
+      join_dependency.join_associations.each do |association|
+        association.join_to(manager)
+      end
+
+      manager.join_sources.concat join_list
+
+      manager
+    end
+
+    def build_select(arel, selects)
+      unless selects.empty?
+        @implicit_readonly = false
+        arel.project(*selects)
+      else
+        arel.project(@klass.arel_table[Arel.star])
+      end
+    end
+
+    def apply_modules(modules)
+      unless modules.empty?
+        @extensions += modules
+        modules.each {|extension| extend(extension) }
+      end
+    end
+
+    def reverse_sql_order(order_query)
+      order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
+
+      order_query.map do |o|
+        case o
+        when Arel::Nodes::Ordering
+          o.reverse
+        when String, Symbol
+          o.to_s.split(',').collect do |s|
+            s.strip!
+            s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+          end
+        else
+          o
+        end
+      end.flatten
+    end
+
+    def array_of_strings?(o)
+      o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
+    end
+
+  end
+end

data/lib/active_record/relation/spawn_methods.rb

@@ -0,0 +1,180 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  module SpawnMethods
+    def merge(r)
+      return self unless r
+      return to_a & r if r.is_a?(Array)
+
+      merged_relation = clone
+
+      r = r.with_default_scope if r.default_scoped? && r.klass != klass
+
+      Relation::ASSOCIATION_METHODS.each do |method|
+        value = r.send(:"#{method}_values")
+
+        unless value.empty?
+          if method == :includes
+            merged_relation = merged_relation.includes(value)
+          else
+            merge_relation_method(merged_relation, method, value)
+          end
+        end
+      end
+
+      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order]).each do |method|
+        value = r.send(:"#{method}_values")
+        merge_relation_method(merged_relation, method, value) if value.present?
+      end
+
+      merge_joins(merged_relation, r)
+
+      merged_wheres = @where_values + r.where_values
+
+      unless @where_values.empty?
+        # Remove duplicate ARel attributes. Last one wins.
+        seen = Hash.new { |h,table| h[table] = {} }
+        merged_wheres = merged_wheres.reverse.reject { |w|
+          nuke = false
+          if w.respond_to?(:operator) && w.operator == :== &&
+            w.left.respond_to?(:relation)
+            name              = w.left.name
+            table             = w.left.relation.name
+            nuke              = seen[table][name]
+            seen[table][name] = true
+          end
+          nuke
+        }.reverse
+      end
+
+      merged_relation.where_values = merged_wheres
+
+      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with, :reordering]).each do |method|
+        value = r.send(:"#{method}_value")
+        merged_relation.send(:"#{method}_value=", value) unless value.nil?
+      end
+
+      merged_relation.lock_value = r.lock_value unless merged_relation.lock_value
+
+      merged_relation = merged_relation.create_with(r.create_with_value) unless r.create_with_value.empty?
+
+      if (r.reordering_value)
+        # override any order specified in the original relation
+        merged_relation.reordering_value = true
+        merged_relation.order_values = r.order_values
+      else
+        # merge in order_values from r
+        merged_relation.order_values += r.order_values
+      end
+
+      # Apply scope extension modules
+      merged_relation.send :apply_modules, r.extensions
+
+      merged_relation
+    end
+
+    # Removes from the query the condition(s) specified in +skips+.
+    #
+    # Example:
+    #
+    #   Post.order('id asc').except(:order)                  # discards the order condition
+    #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
+    #
+    def except(*skips)
+      result = self.class.new(@klass, table)
+      result.default_scoped = default_scoped
+
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - skips).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
+      end
+
+      (Relation::SINGLE_VALUE_METHODS - skips).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
+      end
+
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
+      result
+    end
+
+    # Removes any condition from the query other than the one(s) specified in +onlies+.
+    #
+    # Example:
+    #
+    #   Post.order('id asc').only(:where)         # discards the order condition
+    #   Post.order('id asc').only(:where, :order) # uses the specified order
+    #
+    def only(*onlies)
+      result = self.class.new(@klass, table)
+      result.default_scoped = default_scoped
+
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) & onlies).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
+      end
+
+      (Relation::SINGLE_VALUE_METHODS & onlies).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
+      end
+
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
+      result
+    end
+
+    VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :extend,
+                           :order, :select, :readonly, :group, :having, :from, :lock ]
+
+    def apply_finder_options(options)
+      relation = clone
+      return relation unless options
+
+      options.assert_valid_keys(VALID_FIND_OPTIONS)
+      finders = options.dup
+      finders.delete_if { |key, value| value.nil? && key != :limit }
+
+      ([:joins, :select, :group, :order, :having, :limit, :offset, :from, :lock, :readonly] & finders.keys).each do |finder|
+        relation = relation.send(finder, finders[finder])
+      end
+
+      relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
+      relation = relation.includes(finders[:include]) if options.has_key?(:include)
+      relation = relation.extending(finders[:extend]) if options.has_key?(:extend)
+
+      relation
+    end
+
+    private
+
+      def merge_joins(relation, other)
+        values = other.joins_values
+        return if values.blank?
+
+        if other.klass >= relation.klass
+          relation.joins_values += values
+        else
+          joins_dependency, rest = values.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_values += join_dependency.join_associations + rest
+        end
+      end
+
+      def merge_relation_method(relation, method, value)
+        relation.send(:"#{method}_values=", relation.send(:"#{method}_values") + value)
+      end
+  end
+end