Merge branch 'master' of github.com:rails/rails

16 files changed, 479 insertions, 327 deletions

diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index 2cfd528f2c..7031c67539 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -48,6 +48,7 @@ module ActiveRecord
     autoload :Attributes
     autoload :AutosaveAssociation
     autoload :Relation
+    autoload :RelationalCalculations
     autoload :Base
     autoload :Batches
     autoload :Calculations
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index c23c9f63f1..f0bad6c3ba 100755
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -3,8 +3,8 @@ require 'active_support/core_ext/enumerable'
 
 module ActiveRecord
   class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
-    def initialize(reflection)
-      super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{reflection.class_name})")
+    def initialize(reflection, associated_class = nil)
+      super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
     end
   end
 
@@ -1466,11 +1466,10 @@ module ActiveRecord
         end
 
         def find_with_associations(options = {}, join_dependency = nil)
-          catch :invalid_query do
-            join_dependency ||= JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
-            rows = select_all_rows(options, join_dependency)
-            return join_dependency.instantiate(rows)
-          end
+          join_dependency ||= JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
+          rows = select_all_rows(options, join_dependency)
+          join_dependency.instantiate(rows)
+        rescue ThrowResult
           []
         end
 
@@ -1715,7 +1714,8 @@ module ActiveRecord
 
           relation = relation.joins(construct_join(options[:joins], scope)).
             select(column_aliases(join_dependency)).
-            group(construct_group(options[:group], options[:having], scope)).
+            group(options[:group] || (scope && scope[:group])).
+            having(options[:having] || (scope && scope[:having])).
             order(construct_order(options[:order], scope)).
             where(construct_conditions(options[:conditions], scope)).
             from((scope && scope[:from]) || options[:from])
@@ -1732,7 +1732,7 @@ module ActiveRecord
 
         def construct_arel_limited_ids_condition(options, join_dependency)
           if (ids_array = select_limited_ids_array(options, join_dependency)).empty?
-            throw :invalid_query
+            raise ThrowResult
           else
             Arel::Predicates::In.new(
               Arel::SqlLiteral.new("#{connection.quote_table_name table_name}.#{primary_key}"),
@@ -1759,7 +1759,8 @@ module ActiveRecord
 
           relation = relation.joins(construct_join(options[:joins], scope)).
             where(construct_conditions(options[:conditions], scope)).
-            group(construct_group(options[:group], options[:having], scope)).
+            group(options[:group] || (scope && scope[:group])).
+            having(options[:having] || (scope && scope[:having])).
             order(construct_order(options[:order], scope)).
             limit(construct_limit(options[:limit], scope)).
             offset(construct_limit(options[:offset], scope)).
diff --git a/activerecord/lib/active_record/associations/association_collection.rb b/activerecord/lib/active_record/associations/association_collection.rb
index d2c61cdc78..b2b3a9789c 100644
--- a/activerecord/lib/active_record/associations/association_collection.rb
+++ b/activerecord/lib/active_record/associations/association_collection.rb
@@ -21,7 +21,7 @@ module ActiveRecord
         construct_sql
       end
 
-      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :from, :to => :scoped
+      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :from, :lock, :readonly, :having, :to => :scoped
 
       def select(select = nil, &block)
         if block_given?
@@ -177,7 +177,7 @@ module ActiveRecord
         if @reflection.options[:counter_sql]
           @reflection.klass.count_by_sql(@counter_sql)
         else
-          column_name, options = @reflection.klass.send(:construct_count_options_from_args, *args)
+          column_name, options = @reflection.klass.scoped.send(:construct_count_options_from_args, *args)
           if @reflection.options[:uniq]
             # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
             column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" if column_name == :all
diff --git a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
index 67e18d692d..f6edd6383c 100644
--- a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
@@ -13,6 +13,7 @@ module ActiveRecord
           @updated = true
         end
 
+        set_inverse_instance(record, @owner)
         loaded
         record
       end
@@ -22,21 +23,44 @@ module ActiveRecord
       end
 
       private
-        def find_target
-          return nil if association_class.nil?
 
-          if @reflection.options[:conditions]
-            association_class.find(
-              @owner[@reflection.primary_key_name],
-              :select     => @reflection.options[:select],
-              :conditions => conditions,
-              :include    => @reflection.options[:include]
-            )
+        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+        # has_one associations.
+        def we_can_set_the_inverse_on_this?(record)
+          if @reflection.has_inverse?
+            inverse_association = @reflection.polymorphic_inverse_of(record.class)
+            inverse_association && inverse_association.macro == :has_one
           else
-            association_class.find(@owner[@reflection.primary_key_name], :select => @reflection.options[:select], :include => @reflection.options[:include])
+            false
+          end
+        end
+
+        def set_inverse_instance(record, instance)
+          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
+          inverse_relationship = @reflection.polymorphic_inverse_of(record.class)
+          unless inverse_relationship.nil?
+            record.send(:"set_#{inverse_relationship.name}_target", instance)
           end
         end
 
+        def find_target
+          return nil if association_class.nil?
+
+          target =
+            if @reflection.options[:conditions]
+              association_class.find(
+                @owner[@reflection.primary_key_name],
+                :select     => @reflection.options[:select],
+                :conditions => conditions,
+                :include    => @reflection.options[:include]
+              )
+            else
+              association_class.find(@owner[@reflection.primary_key_name], :select => @reflection.options[:select], :include => @reflection.options[:include])
+            end
+          set_inverse_instance(target, @owner)
+          target
+        end
+
         def foreign_key_present
           !@owner[@reflection.primary_key_name].nil?
         end
diff --git a/activerecord/lib/active_record/associations/has_one_association.rb b/activerecord/lib/active_record/associations/has_one_association.rb
index b85a40b2e5..ea769fd48b 100644
--- a/activerecord/lib/active_record/associations/has_one_association.rb
+++ b/activerecord/lib/active_record/associations/has_one_association.rb
@@ -57,6 +57,7 @@ module ActiveRecord
           @target = (AssociationProxy === obj ? obj.target : obj)
         end
 
+        set_inverse_instance(obj, @owner)
         @loaded = true
 
         unless @owner.new_record? or obj.nil? or dont_save
@@ -120,10 +121,9 @@ module ActiveRecord
           else
             record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
             self.target = record
+            set_inverse_instance(record, @owner)
           end
 
-          set_inverse_instance(record, @owner)
-
           record
         end
 
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index c0d8904bc8..44c668b619 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -155,6 +155,13 @@ module ActiveRecord
 
       # Adds a validate and save callback for the association as specified by
       # the +reflection+.
+      #
+      # For performance reasons, we don't check whether to validate at runtime,
+      # but instead only define the method and callback when needed. However,
+      # this can change, for instance, when using nested attributes. Since we
+      # don't want the callbacks to get defined multiple times, there are
+      # guards that check if the save or validation methods have already been
+      # defined before actually defining them.
       def add_autosave_association_callbacks(reflection)
         save_method = "autosave_associated_records_for_#{reflection.name}"
         validation_method = "validate_associated_records_for_#{reflection.name}"
@@ -162,28 +169,33 @@ module ActiveRecord
 
         case reflection.macro
         when :has_many, :has_and_belongs_to_many
-          before_save :before_save_collection_association
+          unless method_defined?(save_method)
+            before_save :before_save_collection_association
 
-          define_method(save_method) { save_collection_association(reflection) }
-          # Doesn't use after_save as that would save associations added in after_create/after_update twice
-          after_create save_method
-          after_update save_method
+            define_method(save_method) { save_collection_association(reflection) }
+            # Doesn't use after_save as that would save associations added in after_create/after_update twice
+            after_create save_method
+            after_update save_method
+          end
 
-          if force_validation || (reflection.macro == :has_many && reflection.options[:validate] != false)
+          if !method_defined?(validation_method) &&
+              (force_validation || (reflection.macro == :has_many && reflection.options[:validate] != false))
             define_method(validation_method) { validate_collection_association(reflection) }
             validate validation_method
           end
         else
-          case reflection.macro
-          when :has_one
-            define_method(save_method) { save_has_one_association(reflection) }
-            after_save save_method
-          when :belongs_to
-            define_method(save_method) { save_belongs_to_association(reflection) }
-            before_save save_method
+          unless method_defined?(save_method)
+            case reflection.macro
+            when :has_one
+              define_method(save_method) { save_has_one_association(reflection) }
+              after_save save_method
+            when :belongs_to
+              define_method(save_method) { save_belongs_to_association(reflection) }
+              before_save save_method
+            end
           end
 
-          if force_validation
+          if !method_defined?(validation_method) && force_validation
             define_method(validation_method) { validate_single_association(reflection) }
             validate validation_method
           end
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index 3b880ce17f..53f0a920a3 100755
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -69,6 +69,10 @@ module ActiveRecord #:nodoc:
   class StatementInvalid < ActiveRecordError
   end
 
+  # Raised when SQL statement is invalid and the application gets a blank result.
+  class ThrowResult < ActiveRecordError
+  end
+
   # Parent class for all specific exceptions which wrap database driver exceptions
   # provides access to the original exception also.
   class WrappedDatabaseException < StatementInvalid
@@ -652,7 +656,7 @@ module ActiveRecord #:nodoc:
         end
       end
 
-      delegate :select, :group, :order, :limit, :joins, :where, :preload, :eager_load, :from, :to => :scoped
+      delegate :select, :group, :order, :limit, :joins, :where, :preload, :eager_load, :from, :lock, :readonly, :having, :to => :scoped
 
       # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
       # same arguments to this method as you can to <tt>find(:first)</tt>.
@@ -1560,19 +1564,22 @@ module ActiveRecord #:nodoc:
         end
 
         def construct_finder_arel(options = {}, scope = scope(:find))
-          # TODO add lock to Arel
           validate_find_options(options)
 
           relation = arel_table.
             joins(construct_join(options[:joins], scope)).
             where(construct_conditions(options[:conditions], scope)).
             select(options[:select] || (scope && scope[:select]) || default_select(options[:joins] || (scope && scope[:joins]))).
-            group(construct_group(options[:group], options[:having], scope)).
+            group(options[:group] || (scope && scope[:group])).
+            having(options[:having] || (scope && scope[:having])).
             order(construct_order(options[:order], scope)).
             limit(construct_limit(options[:limit], scope)).
             offset(construct_offset(options[:offset], scope)).
             from(options[:from])
 
+          lock = (scope && scope[:lock]) || options[:lock]
+          relation = relation.lock if lock.present?
+
           relation = relation.readonly if options[:readonly]
 
           relation
@@ -1593,10 +1600,6 @@ module ActiveRecord #:nodoc:
           relation
         end
 
-        def construct_finder_sql(options, scope = scope(:find))
-          construct_finder_arel(options, scope).to_sql
-        end
-
         def construct_join(joins, scope)
           merged_joins = scope && scope[:joins] && joins ? merge_joins(scope[:joins], joins) : (joins || scope && scope[:joins])
           case merged_joins
@@ -1613,18 +1616,6 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        def construct_group(group, having, scope)
-          sql = ''
-          if group
-            sql << group.to_s
-            sql << " HAVING #{sanitize_sql_for_conditions(having)}" if having
-          elsif scope && (scoped_group = scope[:group])
-            sql << scoped_group.to_s
-            sql << " HAVING #{sanitize_sql_for_conditions(scope[:having])}" if scope[:having]
-          end
-          sql
-        end
-
         def construct_order(order, scope)
           orders = []
 
@@ -1703,14 +1694,6 @@ module ActiveRecord #:nodoc:
           o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
         end
 
-        # The optional scope argument is for the current <tt>:find</tt> scope.
-        # The <tt>:lock</tt> option has precedence over a scoped <tt>:lock</tt>.
-        def add_lock!(sql, options, scope = :auto)
-          scope = scope(:find) if :auto == scope
-          options = options.reverse_merge(:lock => scope[:lock]) if scope
-          connection.add_lock!(sql, options)
-        end
-
         def type_condition(table_alias=nil)
           quoted_table_alias = self.connection.quote_table_name(table_alias || table_name)
           quoted_inheritance_column = connection.quote_column_name(inheritance_column)
diff --git a/activerecord/lib/active_record/calculations.rb b/activerecord/lib/active_record/calculations.rb
index fcba23dc0d..d51d9f2159 100644
--- a/activerecord/lib/active_record/calculations.rb
+++ b/activerecord/lib/active_record/calculations.rb
@@ -44,7 +44,26 @@ module ActiveRecord
       #
       # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.  Use Person.count instead.
       def count(*args)
-        calculate(:count, *construct_count_options_from_args(*args))
+        case args.size
+        when 0
+          construct_calculation_arel.count
+        when 1
+          if args[0].is_a?(Hash)
+            options = args[0]
+            distinct = options.has_key?(:distinct) ? options.delete(:distinct) : false
+            construct_calculation_arel(options).count(options[:select], :distinct => distinct)
+          else
+            construct_calculation_arel.count(args[0])
+          end
+        when 2
+          column_name, options = args
+          distinct = options.has_key?(:distinct) ? options.delete(:distinct) : false
+          construct_calculation_arel(options).count(column_name, :distinct => distinct)
+        else
+          raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
+        end
+      rescue ThrowResult
+        0
       end
 
       # Calculates the average value on a given column. The value is returned as
@@ -122,168 +141,63 @@ module ActiveRecord
       #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
       #   Person.sum("2 * age")
       def calculate(operation, column_name, options = {})
-        validate_calculation_options(operation, options)
-        operation = operation.to_s.downcase
-
-        scope = scope(:find)
+        construct_calculation_arel(options).calculate(operation, column_name, options.slice(:distinct))
+      rescue ThrowResult
+        0
+      end
 
-        merged_includes = merge_includes(scope ? scope[:include] : [], options[:include])
+      private
+        def validate_calculation_options(options = {})
+          options.assert_valid_keys(CALCULATIONS_OPTIONS)
+        end
 
-        if operation == "count"
-          if merged_includes.any?
-            distinct = true
-            column_name = options[:select] || primary_key
-          end
+        def construct_calculation_arel(options = {})
+          validate_calculation_options(options)
+          options = options.except(:distinct)
 
-          distinct = nil if column_name.to_s =~ /\s*DISTINCT\s+/i
-          distinct ||= options[:distinct]
-        else
-          distinct = nil
-        end
+          scope = scope(:find)
+          includes = merge_includes(scope ? scope[:include] : [], options[:include])
 
-        catch :invalid_query do
-          relation = if merged_includes.any?
-            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, construct_join(options[:joins], scope))
-            construct_finder_arel_with_included_associations(options, join_dependency)
+          if includes.any?
+            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, includes, construct_join(options[:joins], scope))
+            construct_calculation_arel_with_included_associations(options, join_dependency)
           else
-            relation = arel_table(options[:from]).
+            arel_table.
               joins(construct_join(options[:joins], scope)).
+              from((scope && scope[:from]) || options[:from]).
               where(construct_conditions(options[:conditions], scope)).
               order(options[:order]).
               limit(options[:limit]).
-              offset(options[:offset])
-          end
-          if options[:group]
-            return execute_grouped_calculation(operation, column_name, options, relation)
-          else
-            return execute_simple_calculation(operation, column_name, options.merge(:distinct => distinct), relation)
+              offset(options[:offset]).
+              group(options[:group]).
+              having(options[:having]).
+              select(options[:select] || (scope && scope[:select]) || default_select(options[:joins] || (scope && scope[:joins])))
           end
         end
-        0
-      end
-
-      def execute_simple_calculation(operation, column_name, options, relation) #:nodoc:
-        column = if column_names.include?(column_name.to_s)
-          Arel::Attribute.new(arel_table(options[:from] || table_name),
-                              options[:select] || column_name)
-        else
-          Arel::SqlLiteral.new(options[:select] ||
-                               (column_name == :all ? "*" : column_name.to_s))
-        end
-
-        relation = relation.select(operation == 'count' ? column.count(options[:distinct]) : column.send(operation))
-
-        type_cast_calculated_value(connection.select_value(relation.to_sql), column_for(column_name), operation)
-      end
 
-      def execute_grouped_calculation(operation, column_name, options, relation) #:nodoc:
-        group_attr      = options[:group].to_s
-        association     = reflect_on_association(group_attr.to_sym)
-        associated      = association && association.macro == :belongs_to # only count belongs_to associations
-        group_field     = associated ? association.primary_key_name : group_attr
-        group_alias     = column_alias_for(group_field)
-        group_column    = column_for group_field
+        def construct_calculation_arel_with_included_associations(options, join_dependency)
+          scope = scope(:find)
 
-        options[:group] = connection.adapter_name == 'FrontBase' ?  group_alias : group_field
+          relation = arel_table
 
-        aggregate_alias = column_alias_for(operation, column_name)
-
-        options[:select] = (operation == 'count' && column_name == :all) ?
-          "COUNT(*) AS count_all" :
-          Arel::Attribute.new(arel_table, column_name).send(operation).as(aggregate_alias).to_sql
-
-        options[:select] <<  ", #{group_field} AS #{group_alias}"
-
-        relation = relation.select(options[:select]).group(construct_group(options[:group], options[:having], nil))
-
-        calculated_data = connection.select_all(relation.to_sql)
-
-        if association
-          key_ids     = calculated_data.collect { |row| row[group_alias] }
-          key_records = association.klass.base_class.find(key_ids)
-          key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
-        end
-
-        calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
-          key   = type_cast_calculated_value(row[group_alias], group_column)
-          key   = key_records[key] if associated
-          value = row[aggregate_alias]
-          all[key] = type_cast_calculated_value(value, column_for(column_name), operation)
-          all
-        end
-      end
-
-     protected
-        def construct_count_options_from_args(*args)
-          options     = {}
-          column_name = :all
-
-          # We need to handle
-          #   count()
-          #   count(:column_name=:all)
-          #   count(options={})
-          #   count(column_name=:all, options={})
-          #   selects specified by scopes
-          case args.size
-          when 0
-            column_name = scope(:find)[:select] if scope(:find)
-          when 1
-            if args[0].is_a?(Hash)
-              column_name = scope(:find)[:select] if scope(:find)
-              options = args[0]
-            else
-              column_name = args[0]
-            end
-          when 2
-            column_name, options = args
-          else
-            raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
+          for association in join_dependency.join_associations
+            relation = association.join_relation(relation)
           end
 
-          [column_name || :all, options]
-        end
-
-      private
-        def validate_calculation_options(operation, options = {})
-          options.assert_valid_keys(CALCULATIONS_OPTIONS)
-        end
+          relation = relation.joins(construct_join(options[:joins], scope)).
+            select(column_aliases(join_dependency)).
+            group(options[:group]).
+            having(options[:having]).
+            order(options[:order]).
+            where(construct_conditions(options[:conditions], scope)).
+            from((scope && scope[:from]) || options[:from])
 
-        # Converts the given keys to the value that the database adapter returns as
-        # a usable column name:
-        #
-        #   column_alias_for("users.id")                 # => "users_id"
-        #   column_alias_for("sum(id)")                  # => "sum_id"
-        #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
-        #   column_alias_for("count(*)")                 # => "count_all"
-        #   column_alias_for("count", "id")              # => "count_id"
-        def column_alias_for(*keys)
-          table_name = keys.join(' ')
-          table_name.downcase!
-          table_name.gsub!(/\*/, 'all')
-          table_name.gsub!(/\W+/, ' ')
-          table_name.strip!
-          table_name.gsub!(/ +/, '_')
+          relation = relation.where(construct_arel_limited_ids_condition(options, join_dependency)) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
+          relation = relation.limit(construct_limit(options[:limit], scope)) if using_limitable_reflections?(join_dependency.reflections)
 
-          connection.table_alias_for(table_name)
+          relation
         end
 
-        def column_for(field)
-          field_name = field.to_s.split('.').last
-          columns.detect { |c| c.name.to_s == field_name }
-        end
-
-        def type_cast_calculated_value(value, column, operation = nil)
-          case operation
-            when 'count' then value.to_i
-            when 'sum'   then type_cast_using_column(value || '0', column)
-            when 'average'   then value && (value.is_a?(Fixnum) ? value.to_f : value).to_d
-            else type_cast_using_column(value, column)
-          end
-        end
-
-        def type_cast_using_column(value, column)
-          column ? column.type_cast(value) : value
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index be89873632..027d736484 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -181,18 +181,6 @@ module ActiveRecord
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction() end
 
-      # Appends a locking clause to an SQL statement.
-      # This method *modifies* the +sql+ parameter.
-      #   # SELECT * FROM suppliers FOR UPDATE
-      #   add_lock! 'SELECT * FROM suppliers', :lock => true
-      #   add_lock! 'SELECT * FROM suppliers', :lock => ' FOR UPDATE'
-      def add_lock!(sql, options)
-        case lock = options[:lock]
-          when true;   sql << ' FOR UPDATE'
-          when String; sql << " #{lock}"
-        end
-      end
-
       def default_sequence_name(table, column)
         nil
       end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
index c9c2892ba4..78b897add6 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
@@ -183,12 +183,6 @@ module ActiveRecord
         catch_schema_changes { @connection.rollback }
       end
 
-      # SELECT ... FOR UPDATE is redundant since the table is locked.
-      def add_lock!(sql, options) #:nodoc:
-        sql
-      end
-
-
       # SCHEMA STATEMENTS ========================================
 
       def tables(name = nil) #:nodoc:
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index ca3110a374..ff3a51d5c0 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -212,6 +212,11 @@ module ActiveRecord
       #   nested attributes array exceeds the specified limit, NestedAttributes::TooManyRecords
       #   exception is raised. If omitted, any number associations can be processed.
       #   Note that the :limit option is only applicable to one-to-many associations.
+      # [:update_only]
+      #   Allows you to specify that an existing record may only be updated.
+      #   A new record may only be created when there is no existing record.
+      #   This option only works for one-to-one associations and is ignored for
+      #   collection associations. This option is off by default.
       #
       # Examples:
       #   # creates avatar_attributes=
@@ -221,9 +226,9 @@ module ActiveRecord
       #   # creates avatar_attributes= and posts_attributes=
       #   accepts_nested_attributes_for :avatar, :posts, :allow_destroy => true
       def accepts_nested_attributes_for(*attr_names)
-        options = { :allow_destroy => false }
+        options = { :allow_destroy => false, :update_only => false }
         options.update(attr_names.extract_options!)
-        options.assert_valid_keys(:allow_destroy, :reject_if, :limit)
+        options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
 
         attr_names.each do |association_name|
           if reflection = reflect_on_association(association_name)
@@ -235,7 +240,7 @@ module ActiveRecord
             end
 
             reflection.options[:autosave] = true
-
+            add_autosave_association_callbacks(reflection)
             self.nested_attributes_options[association_name.to_sym] = options
 
             if options[:reject_if] == :all_blank
@@ -243,15 +248,13 @@ module ActiveRecord
             end
 
             # def pirate_attributes=(attributes)
-            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes, false)
+            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
             # end
             class_eval %{
               def #{association_name}_attributes=(attributes)
                 assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
               end
             }, __FILE__, __LINE__
-
-            add_autosave_association_callbacks(reflection)
           else
             raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
           end
@@ -286,28 +289,29 @@ module ActiveRecord
 
     # Assigns the given attributes to the association.
     #
-    # If the given attributes include an <tt>:id</tt> that matches the existing
-    # record’s id, then the existing record will be modified. Otherwise a new
-    # record will be built.
+    # If update_only is false and the given attributes include an <tt>:id</tt>
+    # that matches the existing record’s id, then the existing record will be
+    # modified. If update_only is true, a new record is only created when no
+    # object exists. Otherwise a new record will be built.
     #
-    # If the given attributes include a matching <tt>:id</tt> attribute _and_ a
-    # <tt>:_destroy</tt> key set to a truthy value, then the existing record
-    # will be marked for destruction.
+    # If the given attributes include a matching <tt>:id</tt> attribute, or
+    # update_only is true, and a <tt>:_destroy</tt> key set to a truthy value,
+    # then the existing record will be marked for destruction.
     def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
       options = self.nested_attributes_options[association_name]
       attributes = attributes.with_indifferent_access
+      check_existing_record = (options[:update_only] || !attributes['id'].blank?)
 
-      if attributes['id'].blank?
-        unless reject_new_record?(association_name, attributes)
-          method = "build_#{association_name}"
-          if respond_to?(method)
-            send(method, attributes.except(*UNASSIGNABLE_KEYS))
-          else
-            raise ArgumentError, "Cannot build association #{association_name}. Are you trying to build a polymorphic one-to-one association?"
-          end
+      if check_existing_record && (record = send(association_name)) &&
+          (options[:update_only] || record.id.to_s == attributes['id'].to_s)
+        assign_to_or_mark_for_destruction(record, attributes, options[:allow_destroy])
+      elsif !reject_new_record?(association_name, attributes)
+        method = "build_#{association_name}"
+        if respond_to?(method)
+          send(method, attributes.except(*UNASSIGNABLE_KEYS))
+        else
+          raise ArgumentError, "Cannot build association #{association_name}. Are you trying to build a polymorphic one-to-one association?"
         end
-      elsif (existing_record = send(association_name)) && existing_record.id.to_s == attributes['id'].to_s
-        assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
       end
     end
 
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index db5d2b25ed..b751c9ad68 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -214,8 +214,10 @@ module ActiveRecord
       end
 
       def check_validity_of_inverse!
-        if has_inverse? && inverse_of.nil?
-          raise InverseOfAssociationNotFoundError.new(self)
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
         end
       end
 
@@ -237,8 +239,16 @@ module ActiveRecord
       def inverse_of
         if has_inverse?
           @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
-        else
-          nil
+        end
+      end
+
+      def polymorphic_inverse_of(associated_class)
+        if has_inverse?
+          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+            inverse_relationship
+          else
+            raise InverseOfAssociationNotFoundError.new(self, associated_class)
+          end
         end
       end
 
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 530402bf5d..e495aa80db 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -1,9 +1,10 @@
 module ActiveRecord
   class Relation
     delegate :to_sql, :to => :relation
-    delegate :length, :collect, :map, :each, :to => :to_a
+    delegate :length, :collect, :map, :each, :all?, :to => :to_a
     attr_reader :relation, :klass, :associations_to_preload, :eager_load_associations
 
+    include RelationalCalculations
     def initialize(klass, relation, readonly = false, preload = [], eager_load = [])
       @klass, @relation = klass, relation
       @readonly = readonly
@@ -13,6 +14,8 @@ module ActiveRecord
     end
 
     def merge(r)
+      raise ArgumentError, "Cannot merge a #{r.klass.name} relation with #{@klass.name} relation" if r.klass != @klass
+
       joins(r.relation.joins(r.relation)).
         group(r.send(:group_clauses).join(', ')).
         order(r.send(:order_clauses).join(', ')).
@@ -22,7 +25,7 @@ module ActiveRecord
         select(r.send(:select_clauses).join(', ')).
         eager_load(r.eager_load_associations).
         preload(r.associations_to_preload).
-        from(r.send(:sources).any? ? r.send(:from_clauses) : nil)
+        from(r.send(:sources).present? ? r.send(:from_clauses) : nil)
     end
 
     alias :& :merge
@@ -35,18 +38,35 @@ module ActiveRecord
       create_new_relation(@relation, @readonly, @associations_to_preload, @eager_load_associations + Array.wrap(associations))
     end
 
-    def readonly
-      create_new_relation(@relation, true)
+    def readonly(status = true)
+      status.nil? ? create_new_relation : create_new_relation(@relation, status)
     end
 
     def select(selects)
-      selects.present? ? create_new_relation(@relation.project(selects)) : create_new_relation
+      if selects.present?
+        frozen = @relation.joins(relation).present? ? false : @readonly
+        create_new_relation(@relation.project(selects), frozen)
+      else
+        create_new_relation
+      end
     end
 
     def from(from)
       from.present? ? create_new_relation(@relation.from(from)) : create_new_relation
     end
 
+    def having(*args)
+      return create_new_relation if args.blank?
+
+      if [String, Hash, Array].include?(args.first.class)
+        havings = @klass.send(:merge_conditions, args.size > 1 ? Array.wrap(args) : args.first)
+      else
+        havings = args.first
+      end
+
+      create_new_relation(@relation.having(havings))
+    end
+
     def group(groups)
       groups.present? ? create_new_relation(@relation.group(groups)) : create_new_relation
     end
@@ -55,6 +75,17 @@ module ActiveRecord
       orders.present? ? create_new_relation(@relation.order(orders)) : create_new_relation
     end
 
+    def lock(locks = true)
+      case locks
+      when String
+        create_new_relation(@relation.lock(locks))
+      when TrueClass, NilClass
+        create_new_relation(@relation.lock)
+      else
+        create_new_relation
+      end
+    end
+
     def reverse_order
       relation = create_new_relation
       relation.instance_variable_set(:@orders, nil)
@@ -95,7 +126,7 @@ module ActiveRecord
         @relation.join(join, join_type)
       end
 
-      create_new_relation(join_relation)
+      create_new_relation(join_relation, true)
     end
 
     def where(*args)
@@ -118,8 +149,8 @@ module ActiveRecord
       return @records if loaded?
 
       @records = if @eager_load_associations.any?
-        catch :invalid_query do
-          return @klass.send(:find_with_associations, {
+        begin
+          @klass.send(:find_with_associations, {
             :select => @relation.send(:select_clauses).join(', '),
             :joins => @relation.joins(relation),
             :group => @relation.send(:group_clauses).join(', '),
@@ -127,11 +158,12 @@ module ActiveRecord
             :conditions => where_clause,
             :limit => @relation.taken,
             :offset => @relation.skipped,
-            :from => (@relation.send(:from_clauses) if @relation.send(:sources).any?)
+            :from => (@relation.send(:from_clauses) if @relation.send(:sources).present?)
             },
             ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, @eager_load_associations, nil))
+        rescue ThrowResult
+          []
         end
-        []
       else
         @klass.find_by_sql(@relation.to_sql)
       end
diff --git a/activerecord/lib/active_record/relational_calculations.rb b/activerecord/lib/active_record/relational_calculations.rb
new file mode 100644
index 0000000000..d77624c7bf
--- /dev/null
+++ b/activerecord/lib/active_record/relational_calculations.rb
@@ -0,0 +1,169 @@
+module ActiveRecord
+  module RelationalCalculations
+
+    def count(*args)
+      calculate(:count, *construct_count_options_from_args(*args))
+    end
+
+    def average(column_name)
+      calculate(:average, column_name)
+    end
+
+    def minimum(column_name)
+      calculate(:minimum, column_name)
+    end
+
+    def maximum(column_name)
+      calculate(:maximum, column_name)
+    end
+
+    def sum(column_name)
+      calculate(:sum, column_name)
+    end
+
+    def calculate(operation, column_name, options = {})
+      operation = operation.to_s.downcase
+
+      if operation == "count"
+        joins = @relation.joins(relation)
+        if joins.present? && joins =~ /LEFT OUTER/i
+          distinct = true
+          column_name = @klass.primary_key if column_name == :all
+        end
+
+        distinct = nil if column_name.to_s =~ /\s*DISTINCT\s+/i
+        distinct ||= options[:distinct]
+      else
+        distinct = nil
+      end
+
+      distinct = options[:distinct] || distinct
+      column_name = :all if column_name.blank? && operation == "count"
+
+      if @relation.send(:groupings).any?
+        return execute_grouped_calculation(operation, column_name)
+      else
+        return execute_simple_calculation(operation, column_name, distinct)
+      end
+    rescue ThrowResult
+      0
+    end
+
+    private
+
+    def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+      column = if @klass.column_names.include?(column_name.to_s)
+        Arel::Attribute.new(@klass.arel_table, column_name)
+      else
+        Arel::SqlLiteral.new(column_name == :all ? "*" : column_name.to_s)
+      end
+
+      relation = select(operation == 'count' ? column.count(distinct) : column.send(operation))
+      type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
+    end
+
+    def execute_grouped_calculation(operation, column_name) #:nodoc:
+      group_attr      = @relation.send(:groupings).first.value
+      association     = @klass.reflect_on_association(group_attr.to_sym)
+      associated      = association && association.macro == :belongs_to # only count belongs_to associations
+      group_field     = associated ? association.primary_key_name : group_attr
+      group_alias     = column_alias_for(group_field)
+      group_column    = column_for(group_field)
+
+      group = @klass.connection.adapter_name == 'FrontBase' ? group_alias : group_field
+
+      aggregate_alias = column_alias_for(operation, column_name)
+
+      select_statement = if operation == 'count' && column_name == :all
+        "COUNT(*) AS count_all"
+      else
+        Arel::Attribute.new(@klass.arel_table, column_name).send(operation).as(aggregate_alias).to_sql
+      end
+
+      select_statement <<  ", #{group_field} AS #{group_alias}"
+
+      relation = select(select_statement).group(group)
+
+      calculated_data = @klass.connection.select_all(relation.to_sql)
+
+      if association
+        key_ids     = calculated_data.collect { |row| row[group_alias] }
+        key_records = association.klass.base_class.find(key_ids)
+        key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
+      end
+
+      calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
+        key   = type_cast_calculated_value(row[group_alias], group_column)
+        key   = key_records[key] if associated
+        value = row[aggregate_alias]
+        all[key] = type_cast_calculated_value(value, column_for(column_name), operation)
+        all
+      end
+    end
+
+    def construct_count_options_from_args(*args)
+      options     = {}
+      column_name = :all
+
+      # Handles count(), count(:column), count(:distinct => true), count(:column, :distinct => true)
+      # TODO : relation.projections only works when .select() was last in the chain. Fix it!
+      case args.size
+      when 0
+        select = @relation.send(:select_clauses).join(', ') if @relation.respond_to?(:projections) && @relation.projections.present?
+        column_name = select if select !~ /(,|\*)/
+      when 1
+        if args[0].is_a?(Hash)
+          select = @relation.send(:select_clauses).join(', ') if @relation.respond_to?(:projections) && @relation.projections.present?
+          column_name = select if select !~ /(,|\*)/
+          options = args[0]
+        else
+          column_name = args[0]
+        end
+      when 2
+        column_name, options = args
+      else
+        raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
+      end
+
+      [column_name || :all, options]
+    end
+
+    # Converts the given keys to the value that the database adapter returns as
+    # a usable column name:
+    #
+    #   column_alias_for("users.id")                 # => "users_id"
+    #   column_alias_for("sum(id)")                  # => "sum_id"
+    #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
+    #   column_alias_for("count(*)")                 # => "count_all"
+    #   column_alias_for("count", "id")              # => "count_id"
+    def column_alias_for(*keys)
+      table_name = keys.join(' ')
+      table_name.downcase!
+      table_name.gsub!(/\*/, 'all')
+      table_name.gsub!(/\W+/, ' ')
+      table_name.strip!
+      table_name.gsub!(/ +/, '_')
+
+      @klass.connection.table_alias_for(table_name)
+    end
+
+    def column_for(field)
+      field_name = field.to_s.split('.').last
+      @klass.columns.detect { |c| c.name.to_s == field_name }
+    end
+
+    def type_cast_calculated_value(value, column, operation = nil)
+      case operation
+        when 'count' then value.to_i
+        when 'sum'   then type_cast_using_column(value || '0', column)
+        when 'average'   then value && (value.is_a?(Fixnum) ? value.to_f : value).to_d
+        else type_cast_using_column(value, column)
+      end
+    end
+
+    def type_cast_using_column(value, column)
+      column ? column.type_cast(value) : value
+    end
+
+  end
+end
diff --git a/activerecord/lib/active_record/validations/associated.rb b/activerecord/lib/active_record/validations/associated.rb
index 92f47d770f..66b78682ad 100644
--- a/activerecord/lib/active_record/validations/associated.rb
+++ b/activerecord/lib/active_record/validations/associated.rb
@@ -1,5 +1,12 @@
 module ActiveRecord
   module Validations
+    class AssociatedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        return if (value.is_a?(Array) ? value : [value]).collect{ |r| r.nil? || r.valid? }.all?
+        record.errors.add(attribute, :invalid, :default => options[:message], :value => value)
+      end
+    end
+
     module ClassMethods
       # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
       #
@@ -33,13 +40,8 @@ module ActiveRecord
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_associated(*attr_names)
-        configuration = attr_names.extract_options!
-
-        validates_each(attr_names, configuration) do |record, attr_name, value|
-          unless (value.is_a?(Array) ? value : [value]).collect { |r| r.nil? || r.valid? }.all?
-            record.errors.add(attr_name, :invalid, :default => configuration[:message], :value => value)
-          end
-        end
+        options = attr_names.extract_options!
+        validates_with AssociatedValidator, options.merge(:attributes => attr_names)
       end
     end
   end
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index 711086dc2c..ffbe1b5c40 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -1,5 +1,77 @@
 module ActiveRecord
   module Validations
+    class UniquenessValidator < ActiveModel::EachValidator
+      def initialize(options)
+        @klass = options.delete(:klass)
+        super(options.reverse_merge(:case_sensitive => true))
+      end
+
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        table_name   = record.class.quoted_table_name
+        sql, params  = mount_sql_and_params(finder_class, table_name, attribute, value)
+
+        Array(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          sql << " AND " << record.class.send(:attribute_condition, "#{table_name}.#{scope_item}", scope_value)
+          params << scope_value
+        end
+
+        unless record.new_record?
+          sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
+          params << record.send(:id)
+        end
+
+        finder_class.send(:with_exclusive_scope) do
+          if finder_class.exists?([sql, *params])
+            record.errors.add(attribute, :taken, :default => options[:message], :value => value)
+          end
+        end
+      end
+
+    protected
+
+      # The check for an existing value should be run from a class that
+      # isn't abstract. This means working down from the current class
+      # (self), to the first non-abstract class. Since classes don't know
+      # their subclasses, we have to build the hierarchy between self and
+      # the record's class.
+      def find_finder_class_for(record) #:nodoc:
+        class_hierarchy = [record.class]
+
+        while class_hierarchy.first != @klass
+          class_hierarchy.insert(0, class_hierarchy.first.superclass)
+        end
+
+        class_hierarchy.detect { |klass| !klass.abstract_class? }
+      end
+
+      def mount_sql_and_params(klass, table_name, attribute, value) #:nodoc:
+        column = klass.columns_hash[attribute.to_s]
+
+        operator = if value.nil?
+          "IS ?"
+        elsif column.text?
+          value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
+          "#{klass.connection.case_sensitive_equality_operator} ?"
+        else
+          "= ?"
+        end
+
+        sql_attribute = "#{table_name}.#{klass.connection.quote_column_name(attribute)}"
+
+        if value.nil? || (options[:case_sensitive] || !column.text?)
+          sql = "#{sql_attribute} #{operator}"
+          params = [value]
+        else
+          sql = "LOWER(#{sql_attribute}) #{operator}"
+          params = [value.mb_chars.downcase]
+        end
+
+        [sql, params]
+      end
+    end
+
     module ClassMethods
       # Validates whether the value of the specified attributes are unique across the system. Useful for making sure that only one user
       # can be named "davidhh".
@@ -69,6 +141,7 @@ module ActiveRecord
       #
       # This could even happen if you use transactions with the 'serializable'
       # isolation level. There are several ways to get around this problem:
+      #
       # - By locking the database table before validating, and unlocking it after
       #   saving. However, table locking is very expensive, and thus not
       #   recommended.
@@ -94,65 +167,10 @@ module ActiveRecord
       #   index constraint errors from other types of database errors, so you
       #   will have to parse the (database-specific) exception message to detect
       #   such a case.
+      #
       def validates_uniqueness_of(*attr_names)
-        configuration = { :case_sensitive => true }
-        configuration.update(attr_names.extract_options!)
-
-        validates_each(attr_names,configuration) do |record, attr_name, value|
-          # The check for an existing value should be run from a class that
-          # isn't abstract. This means working down from the current class
-          # (self), to the first non-abstract class. Since classes don't know
-          # their subclasses, we have to build the hierarchy between self and
-          # the record's class.
-          class_hierarchy = [record.class]
-          while class_hierarchy.first != self
-            class_hierarchy.insert(0, class_hierarchy.first.superclass)
-          end
-
-          # Now we can work our way down the tree to the first non-abstract
-          # class (which has a database table to query from).
-          finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
-
-          column = finder_class.columns_hash[attr_name.to_s]
-
-          if value.nil?
-            comparison_operator = "IS ?"
-          elsif column.text?
-            comparison_operator = "#{connection.case_sensitive_equality_operator} ?"
-            value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
-          else
-            comparison_operator = "= ?"
-          end
-
-          sql_attribute = "#{record.class.quoted_table_name}.#{connection.quote_column_name(attr_name)}"
-
-          if value.nil? || (configuration[:case_sensitive] || !column.text?)
-            condition_sql = "#{sql_attribute} #{comparison_operator}"
-            condition_params = [value]
-          else
-            condition_sql = "LOWER(#{sql_attribute}) #{comparison_operator}"
-            condition_params = [value.mb_chars.downcase]
-          end
-
-          if scope = configuration[:scope]
-            Array(scope).map do |scope_item|
-              scope_value = record.send(scope_item)
-              condition_sql << " AND " << attribute_condition("#{record.class.quoted_table_name}.#{scope_item}", scope_value)
-              condition_params << scope_value
-            end
-          end
-
-          unless record.new_record?
-            condition_sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
-            condition_params << record.send(:id)
-          end
-
-          finder_class.with_exclusive_scope do
-            if finder_class.exists?([condition_sql, *condition_params])
-              record.errors.add(attr_name, :taken, :default => configuration[:message], :value => value)
-            end
-          end
-        end
+        options = attr_names.extract_options!
+        validates_with UniquenessValidator, options.merge(:attributes => attr_names, :klass => self)
       end
     end
   end