activerecord 3.1.12 → 3.2.22.1

data/lib/active_record/reflection.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/module/deprecation'
 require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
@@ -125,7 +124,7 @@ module ActiveRecord
       # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
       # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
       def class_name
-        @class_name ||= options[:class_name] || derive_class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
       end
 
       # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
@@ -178,15 +177,9 @@ module ActiveRecord
         @collection = macro.in?([:has_many, :has_and_belongs_to_many])
       end
 
-      # This is a hack so that we can tell if build_association was overridden, in order to
-      # provide an appropriate deprecation if the overridden method ignored the &block. Please
-      # see Association#build_record for details.
-      attr_accessor :original_build_association_called # :nodoc
-
       # Returns a new, unsaved instance of the associated class. +options+ will
       # be passed to the class's constructor.
       def build_association(*options, &block)
-        @original_build_association_called = true
         klass.new(*options, &block)
       end
 
@@ -202,11 +195,6 @@ module ActiveRecord
         @foreign_key ||= options[:foreign_key] || derive_foreign_key
       end
 
-      def primary_key_name
-        foreign_key
-      end
-      deprecate :primary_key_name => :foreign_key
-
       def foreign_type
         @foreign_type ||= options[:foreign_type] || "#{name}_type"
       end
@@ -274,6 +262,10 @@ module ActiveRecord
         [self]
       end
 
+      def nested?
+        false
+      end
+
       # An array of arrays of conditions. Each item in the outside array corresponds to a reflection
       # in the #chain. The inside arrays are simply conditions (and each condition may itself be
       # a hash, array, arel predicate, etc...)
@@ -381,7 +373,7 @@ module ActiveRecord
       delegate :foreign_key, :foreign_type, :association_foreign_key,
                :active_record_primary_key, :type, :to => :source_reflection
 
-      # Gets the source of the through reflection.  It checks both a singularized
+      # Gets the source of the through reflection. It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
       #   class Post < ActiveRecord::Base
@@ -469,7 +461,7 @@ module ActiveRecord
         source_reflection.source_macro
       end
 
-      # A through association is nested iff there would be more than one join table
+      # A through association is nested if there would be more than one join table
       def nested?
         chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
       end

data/lib/active_record/relation/batches.rb

@@ -59,18 +59,21 @@ module ActiveRecord
         relation = apply_finder_options(finder_options)
       end
 
-      start = options.delete(:start).to_i
+      start = options.delete(:start)
       batch_size = options.delete(:batch_size) || 1000
 
       relation = relation.reorder(batch_order).limit(batch_size)
-      records = relation.where(table[primary_key].gteq(start)).all
+      records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
 
       while records.any?
+        records_size = records.size
+        primary_key_offset = records.last.id
+
         yield records
 
-        break if records.size < batch_size
+        break if records_size < batch_size
 
-        if primary_key_offset = records.last.id
+        if primary_key_offset
           records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
         else
           raise "Primary key not included in the custom select clause"

data/lib/active_record/relation/calculations.rb

@@ -66,7 +66,7 @@ module ActiveRecord
       calculate(:average, column_name, options)
     end
 
-    # Calculates the minimum value on a given column.  The value is returned
+    # Calculates the minimum value on a given column. The value is returned
     # with the same data type of the column, or +nil+ if there's no row. See
     # +calculate+ for examples with options.
     #
@@ -89,11 +89,15 @@ module ActiveRecord
     # +calculate+ for examples with options.
     #
     #   Person.sum('age') # => 4562
-    def sum(column_name, options = {})
-      calculate(:sum, column_name, options)
+    def sum(*args)
+      if block_given?
+        self.to_a.sum(*args) {|*block_args| yield(*block_args)}
+      else
+        calculate(:sum, *args)
+      end
     end
 
-    # This calculates aggregate values in the given column.  Methods for count, sum, average,
+    # This calculates aggregate values in the given column. Methods for count, sum, average,
     # minimum, and maximum have been added as shortcuts. Options such as <tt>:conditions</tt>,
     # <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
     #
@@ -101,7 +105,7 @@ module ActiveRecord
     #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float
     #     for AVG, and the given column's type for everything else.
     #   * Grouped values: This returns an ordered hash of the values and groups them by the
-    #     <tt>:group</tt> option.  It takes either a column name, or the name of a belongs_to association.
+    #     <tt>:group</tt> option. It takes either a column name, or the name of a belongs_to association.
     #
     #       values = Person.maximum(:age, :group => 'last_name')
     #       puts values["Drake"]
@@ -119,7 +123,7 @@ module ActiveRecord
     # Options:
     # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ].
     #   See conditions in the intro to ActiveRecord::Base.
-    # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything,
+    # * <tt>:include</tt>: Eager loading, see Associations for details. Since calculations don't load anything,
     #   the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
     # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id".
     #   (Rarely needed).
@@ -162,12 +166,36 @@ module ActiveRecord
       0
     end
 
+    # This method is designed to perform select by a single column as direct SQL query
+    # Returns <tt>Array</tt> with values of the specified column name
+    # The values has same data type as column.
+    #
+    # Examples:
+    #
+    #   Person.pluck(:id) # SELECT people.id FROM people
+    #   Person.uniq.pluck(:role) # SELECT DISTINCT role FROM people
+    #   Person.where(:confirmed => true).limit(5).pluck(:id)
+    #
+    def pluck(column_name)
+      if column_name.is_a?(Symbol) && column_names.include?(column_name.to_s)
+        column_name = "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column_name)}"
+      end
+
+      result = klass.connection.exec_query(select(column_name).to_sql)
+      last_column = result.columns.last
+
+      result.map do |attributes|
+        klass.type_cast_attribute(last_column, klass.initialize_attributes(attributes))
+      end
+    end
+
     private
 
     def perform_calculation(operation, column_name, options = {})
       operation = operation.to_s.downcase
 
-      distinct = options[:distinct]
+      # If #count is used in conjuction with #uniq it is considered distinct. (eg. relation.uniq.count)
+      distinct = options[:distinct] || self.uniq_value
 
       if operation == "count"
         column_name ||= (select_for_count || :all)
@@ -223,10 +251,16 @@ module ActiveRecord
     end
 
     def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
-      group_attr      = @group_values
-      association     = @klass.reflect_on_association(group_attr.first.to_sym)
-      associated      = group_attr.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
-      group_fields  = Array(associated ? association.foreign_key : group_attr)
+      group_attrs = @group_values
+
+      if group_attrs.first.respond_to?(:to_sym)
+        association  = @klass.reflect_on_association(group_attrs.first.to_sym)
+        associated   = group_attrs.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
+        group_fields = Array(associated ? association.foreign_key : group_attrs)
+      else
+        group_fields = group_attrs
+      end
+
       group_aliases = group_fields.map { |field| column_alias_for(field) }
       group_columns = group_aliases.zip(group_fields).map { |aliaz,field|
         [aliaz, column_for(field)]
@@ -249,10 +283,14 @@ module ActiveRecord
       select_values += @select_values unless @having_values.empty?
 
       select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
-        "#{field} AS #{aliaz}"
+        if field.respond_to?(:as)
+          field.as(aliaz)
+        else
+          "#{field} AS #{aliaz}"
+        end
       }
 
-      relation = except(:group).group(group.join(','))
+      relation = except(:group).group(group)
       relation.select_values = select_values
 
       calculated_data = @klass.connection.select_all(relation)
@@ -264,10 +302,10 @@ module ActiveRecord
       end
 
       ActiveSupport::OrderedHash[calculated_data.map do |row|
-        key   = group_columns.map { |aliaz, column|
+        key = group_columns.map { |aliaz, column|
           type_cast_calculated_value(row[aliaz], column)
         }
-        key   = key.first if key.size == 1
+        key = key.first if key.size == 1
         key = key_records[key] if associated
         [key, type_cast_calculated_value(row[aggregate_alias], column_for(column_name), operation)]
       end]
@@ -282,6 +320,7 @@ module ActiveRecord
     #   column_alias_for("count(*)")                 # => "count_all"
     #   column_alias_for("count", "id")              # => "count_id"
     def column_alias_for(*keys)
+      keys.map! {|k| k.respond_to?(:to_sql) ? k.to_sql : k}
       table_name = keys.join(' ')
       table_name.downcase!
       table_name.gsub!(/\*/, 'all')
@@ -293,7 +332,7 @@ module ActiveRecord
     end
 
     def column_for(field)
-      field_name = field.to_s.split('.').last
+      field_name = field.respond_to?(:name) ? field.name.to_s : field.to_s.split('.').last
       @klass.columns.detect { |c| c.name.to_s == field_name }
     end
 

data/lib/active_record/relation/delegation.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActiveRecord
+  module Delegation
+    # Set up common delegations for performance (avoids method_missing)
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :to => :to_a
+    delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
+             :connection, :columns_hash, :auto_explain_threshold_in_seconds, :to => :klass
+
+    def self.delegate_to_scoped_klass(method)
+      if method.to_s =~ /\A[a-zA-Z_]\w*[!?]?\z/
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)
+            scoping { @klass.#{method}(*args, &block) }
+          end
+        RUBY
+      else
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)
+            scoping { @klass.send(#{method.inspect}, *args, &block) }
+          end
+        RUBY
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || Array.method_defined?(method) ||
+        @klass.respond_to?(method, include_private) ||
+        arel.respond_to?(method, include_private)
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      if @klass.respond_to?(method)
+        ::ActiveRecord::Delegation.delegate_to_scoped_klass(method)
+        scoping { @klass.send(method, *args, &block) }
+      elsif Array.method_defined?(method)
+        ::ActiveRecord::Delegation.delegate method, :to => :to_a
+        to_a.send(method, *args, &block)
+      elsif arel.respond_to?(method)
+        ::ActiveRecord::Delegation.delegate method, :to => :arel
+        arel.send(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/active_record/relation/finder_methods.rb

@@ -83,7 +83,7 @@ module ActiveRecord
     #
     # 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
+    # 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>.
     #
@@ -134,8 +134,8 @@ module ActiveRecord
     def last(*args)
       if args.any?
         if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          if order_values.empty? && reorder_value.nil?
-            order("#{primary_key} DESC").limit(*args).reverse
+          if order_values.empty? && primary_key
+            order("#{quoted_table_name}.#{quoted_primary_key} DESC").limit(*args).reverse
           else
             to_a.last(*args)
           end
@@ -185,13 +185,12 @@ module ActiveRecord
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
     #   Person.exists?
     def exists?(id = false)
-      return false if id.nil?
-
       id = id.id if ActiveRecord::Base === id
+      return false if id.nil?
 
       join_dependency = construct_join_dependency_for_association_find
       relation = construct_relation_for_association_find(join_dependency)
-      relation = relation.except(:select).select("1").limit(1)
+      relation = relation.except(:select, :order).select("1 AS one").limit(1)
 
       case id
       when Array, Hash
@@ -200,7 +199,9 @@ module ActiveRecord
         relation = relation.where(table[primary_key].eq(id)) if id
       end
 
-      connection.select_value(relation) ? true : false
+      connection.select_value(relation, "#{name} Exists") ? true : false
+    rescue ThrowResult
+      false
     end
 
     protected
@@ -252,9 +253,12 @@ module ActiveRecord
       orders = relation.order_values.map { |val| val.presence }.compact
       values = @klass.connection.distinct("#{@klass.connection.quote_table_name table_name}.#{primary_key}", orders)
 
-      relation = relation.dup
+      relation = relation.dup.select(values)
+      relation.uniq_value = nil
+
+      id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
+      ids_array = id_rows.map {|row| row[primary_key]}
 
-      ids_array = relation.select(values).collect {|row| row[primary_key]}
       ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
     end
 
@@ -262,9 +266,10 @@ module ActiveRecord
       conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
       result = where(conditions).send(match.finder)
 
-      if match.bang? && result.blank?
+      if match.bang? && result.nil?
         raise RecordNotFound, "Couldn't find #{@klass.name} with #{conditions.to_a.collect {|p| p.join(' = ')}.join(', ')}"
       else
+        yield(result) if block_given?
         result
       end
     end
@@ -289,7 +294,7 @@ module ActiveRecord
           r.assign_attributes(unprotected_attributes_for_create, :without_protection => true)
         end
         yield(record) if block_given?
-        record.save if match.instantiator == :create
+        record.send(match.save_method) if match.save_record?
       end
 
       record

data/lib/active_record/relation/predicate_builder.rb

@@ -27,21 +27,23 @@ module ActiveRecord
             value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
             attribute.in(value.arel.ast)
           when Array, ActiveRecord::Associations::CollectionProxy
-            values = value.to_a.map { |x|
-              x.is_a?(ActiveRecord::Base) ? x.id : x
-            }
+            values = value.to_a.map {|x| x.is_a?(ActiveRecord::Base) ? x.id : x}
+            ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+
+            array_predicates = ranges.map {|range| attribute.in(range)}
 
             if values.include?(nil)
               values = values.compact
               if values.empty?
-                attribute.eq nil
+                array_predicates << attribute.eq(nil)
               else
-                attribute.in(values.compact).or attribute.eq(nil)
+                array_predicates << attribute.in(values.compact).or(attribute.eq(nil))
               end
             else
-              attribute.in(values)
+              array_predicates << attribute.in(values)
             end
 
+            array_predicates.inject {|composite, predicate| composite.or(predicate)}
           when Range, Arel::Relation
             attribute.in(value)
           when ActiveRecord::Base

data/lib/active_record/relation/query_methods.rb

@@ -9,7 +9,8 @@ module ActiveRecord
                   :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, :reorder_value, :reverse_order_value
+                  :from_value, :reordering_value, :reverse_order_value,
+                  :uniq_value
 
     def includes(*args)
       args.reject! {|a| a.blank? }
@@ -38,7 +39,7 @@ module ActiveRecord
     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 }
@@ -56,16 +57,16 @@ module ActiveRecord
     # array, it actually returns a relation object and can have other query
     # methods appended to it, such as the other methods in ActiveRecord::QueryMethods.
     #
-    # This method will also take multiple parameters:
+    # The argument to the method can also be an array of fields.
     #
-    #   >> Model.select(:field, :other_field, :and_one_more)
+    #   >> 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 return `nil` when the getter method for that attribute is used:
+    # will raise a ActiveModel::MissingAttributeError when the getter method for that attribute is used:
     #
     #   >> Model.select(:field).first.other_field
-    #   => nil
+    #   => ActiveModel::MissingAttributeError: missing attribute: other_field
     def select(value = Proc.new)
       if block_given?
         to_a.select {|*block_args| value.call(*block_args) }
@@ -92,11 +93,22 @@ module ActiveRecord
       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.reorder_value = args.flatten
+      relation.reordering_value = true
+      relation.order_values = args.flatten
       relation
     end
 
@@ -176,6 +188,58 @@ module ActiveRecord
       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?
 
@@ -210,12 +274,13 @@ module ActiveRecord
 
       arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
 
-      order = @reorder_value ? @reorder_value : @order_values
+      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
 
@@ -331,10 +396,11 @@ module ActiveRecord
 
       order_query.map do |o|
         case o
-        when Arel::Nodes::Ascending, Arel::Nodes::Descending
+        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

data/lib/active_record/relation/spawn_methods.rb

@@ -17,26 +17,27 @@ module ActiveRecord
           if method == :includes
             merged_relation = merged_relation.includes(value)
           else
-            merged_relation.send(:"#{method}_values=", value)
+            merge_relation_method(merged_relation, method, value)
           end
         end
       end
 
-      (Relation::MULTI_VALUE_METHODS - [:joins, :where]).each do |method|
+      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order]).each do |method|
         value = r.send(:"#{method}_values")
-        merged_relation.send(:"#{method}_values=", merged_relation.send(:"#{method}_values") + value) if value.present?
+        merge_relation_method(merged_relation, method, value) if value.present?
       end
 
-      merged_relation.joins_values += r.joins_values
+      merge_joins(merged_relation, r)
 
       merged_wheres = @where_values + r.where_values
 
       unless @where_values.empty?
-        # Remove duplicates, last one wins.
+        # 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 == :==
+          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]
@@ -48,7 +49,7 @@ module ActiveRecord
 
       merged_relation.where_values = merged_wheres
 
-      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with]).each do |method|
+      (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
@@ -57,6 +58,15 @@ module ActiveRecord
 
       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
 
@@ -135,5 +145,36 @@ module ActiveRecord
       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