activerecord 3.0.3 → 3.0.4.rc1

data/CHANGELOG

@@ -1,3 +1,9 @@
+*Rails 3.0.4 (unreleased)*
+
+* Added deprecation warning for has_and_belongs_to_many associations where the join table has
+  additional attributes other than the keys. Access to these attributes is removed in 3.1.
+  Please use has_many :through instead. [Jon Leighton]
+
 *Rails 3.0.3 (November 16, 2010)*
 
 * Support find by class like this: Post.where(:name => Post)

data/lib/active_record/aggregations.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     def clear_aggregation_cache #:nodoc:
       self.class.reflect_on_all_aggregations.to_a.each do |assoc|
         instance_variable_set "@#{assoc.name}", nil
-      end if self.persisted?
+      end unless self.new_record?
     end
 
     # Active Record implements aggregation through a macro-like class method called +composed_of+

data/lib/active_record/association_preload.rb

@@ -193,13 +193,17 @@ module ActiveRecord
         conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
         conditions << append_conditions(reflection, preload_options)
 
-        associated_records = reflection.klass.unscoped.where([conditions, ids]).
+        associated_records_proxy = reflection.klass.unscoped.
             includes(options[:include]).
             joins("INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}").
             select("#{options[:select] || table_name+'.*'}, t0.#{reflection.primary_key_name} as the_parent_record_id").
-            order(options[:order]).to_a
+            order(options[:order])
 
-        set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'the_parent_record_id')
+        all_associated_records = associated_records(ids) do |some_ids|
+          associated_records_proxy.where([conditions, ids]).to_a
+        end
+
+        set_association_collection_records(id_to_record_map, reflection.name, all_associated_records, 'the_parent_record_id')
       end
 
       def preload_has_one_association(records, reflection, preload_options={})
@@ -336,9 +340,8 @@ module ActiveRecord
           klass = klass_name.constantize
 
           table_name = klass.quoted_table_name
-          primary_key = reflection.options[:primary_key] || klass.primary_key
+          primary_key = (reflection.options[:primary_key] || klass.primary_key).to_s
           column_type = klass.columns.detect{|c| c.name == primary_key}.type
-
           ids = id_map.keys.map do |id|
             if column_type == :integer
               id.to_i
@@ -374,13 +377,14 @@ module ActiveRecord
         find_options = {
           :select => preload_options[:select] || options[:select] || Arel::SqlLiteral.new("#{table_name}.*"),
           :include => preload_options[:include] || options[:include],
-          :conditions => [conditions, ids],
           :joins => options[:joins],
           :group => preload_options[:group] || options[:group],
           :order => preload_options[:order] || options[:order]
         }
 
-        reflection.klass.scoped.apply_finder_options(find_options).to_a
+        associated_records(ids) do |some_ids|
+          reflection.klass.scoped.apply_finder_options(find_options.merge(:conditions => [conditions, some_ids])).to_a
+        end
       end
 
 
@@ -398,6 +402,17 @@ module ActiveRecord
       def in_or_equals_for_ids(ids)
         ids.size > 1 ? "IN (?)" : "= ?"
       end
+
+      # Some databases impose a limit on the number of ids in a list (in Oracle its 1000)
+      # Make several smaller queries if necessary or make one query if the adapter supports it
+      def associated_records(ids)
+        max_ids_in_a_list = connection.ids_in_list_limit || ids.size
+        records = []
+        ids.each_slice(max_ids_in_a_list) do |some_ids|
+          records += yield(some_ids)
+        end
+        records
+      end
     end
   end
 end

data/lib/active_record/associations.rb

@@ -118,7 +118,7 @@ module ActiveRecord
     def clear_association_cache #:nodoc:
       self.class.reflect_on_all_associations.to_a.each do |assoc|
         instance_variable_set "@#{assoc.name}", nil
-      end if self.persisted?
+      end unless self.new_record?
     end
 
     private
@@ -2156,14 +2156,19 @@ module ActiveRecord
               when :has_many, :has_one
                 if reflection.options[:through]
                   join_table = Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine)
-                  jt_foreign_key = jt_as_extra = jt_source_extra = jt_sti_extra = nil
+                  jt_as_extra = jt_source_extra = jt_sti_extra = nil
                   first_key = second_key = as_extra = nil
 
-                  if through_reflection.options[:as] # has_many :through against a polymorphic join
-                    jt_foreign_key = through_reflection.options[:as].to_s + '_id'
-                    jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].eq(parent.active_record.base_class.name)
+                  if through_reflection.macro == :belongs_to
+                    jt_primary_key = through_reflection.primary_key_name
+                    jt_foreign_key = through_reflection.association_primary_key
                   else
+                    jt_primary_key = through_reflection.active_record_primary_key
                     jt_foreign_key = through_reflection.primary_key_name
+
+                    if through_reflection.options[:as] # has_many :through against a polymorphic join
+                      jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].eq(parent.active_record.base_class.name)
+                    end
                   end
 
                   case source_reflection.macro
@@ -2191,7 +2196,7 @@ module ActiveRecord
                   end
 
                   [
-                    [parent_table[parent.primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra].reject{|x| x.blank? },
+                    [parent_table[jt_primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra].reject{|x| x.blank? },
                     aliased_table[first_key].eq(join_table[second_key])
                   ]
                 elsif reflection.options[:as]

data/lib/active_record/associations/association_collection.rb

@@ -127,13 +127,13 @@ module ActiveRecord
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def <<(*records)
         result = true
-        load_target unless @owner.persisted?
+        load_target if @owner.new_record?
 
         transaction do
           flatten_deeper(records).each do |record|
             raise_on_type_mismatch(record)
             add_record_to_target_with_callbacks(record) do |r|
-              result &&= insert_record(record) if @owner.persisted?
+              result &&= insert_record(record) unless @owner.new_record?
             end
           end
         end
@@ -291,12 +291,12 @@ module ActiveRecord
       # This method is abstract in the sense that it relies on
       # +count_records+, which is a method descendants have to provide.
       def size
-        if !@owner.persisted? || (loaded? && !@reflection.options[:uniq])
+        if @owner.new_record? || (loaded? && !@reflection.options[:uniq])
           @target.size
         elsif !loaded? && @reflection.options[:group]
           load_target.size
         elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
-          unsaved_records = @target.reject { |r| r.persisted? }
+          unsaved_records = @target.select { |r| r.new_record? }
           unsaved_records.size + count_records
         else
           count_records
@@ -363,7 +363,7 @@ module ActiveRecord
 
       def include?(record)
         return false unless record.is_a?(@reflection.klass)
-        return include_in_memory?(record) unless record.persisted?
+        return include_in_memory?(record) if record.new_record?
         load_target if @reflection.options[:finder_sql] && !loaded?
         return @target.include?(record) if loaded?
         exists?(record)
@@ -390,7 +390,7 @@ module ActiveRecord
         end
 
         def load_target
-          if @owner.persisted? || foreign_key_present
+          if !@owner.new_record? || foreign_key_present
             begin
               if !loaded?
                 if @target.is_a?(Array) && @target.any?
@@ -521,7 +521,7 @@ module ActiveRecord
 
           transaction do
             records.each { |record| callback(:before_remove, record) }
-            old_records = records.select { |r| r.persisted? }
+            old_records = records.reject { |r| r.new_record? }
             yield(records, old_records)
             records.each { |record| callback(:after_remove, record) }
           end
@@ -546,23 +546,22 @@ module ActiveRecord
         end
 
         def ensure_owner_is_not_new
-          unless @owner.persisted?
+          if @owner.new_record?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
           end
         end
 
         def fetch_first_or_last_using_find?(args)
-          args.first.kind_of?(Hash) || !(loaded? || !@owner.persisted? || @reflection.options[:finder_sql] ||
-                                         !@target.all? { |record| record.persisted? } || args.first.kind_of?(Integer))
+          args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] ||
+                                         @target.any? { |record| record.new_record? } || args.first.kind_of?(Integer))
         end
 
         def include_in_memory?(record)
           if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-            @owner.send(proxy_reflection.through_reflection.name.to_sym).map do |source|
-              source_reflection_target = source.send(proxy_reflection.source_reflection.name)
-              return true if source_reflection_target.respond_to?(:include?) ? source_reflection_target.include?(record) : source_reflection_target == record
-            end
-            false
+            @owner.send(proxy_reflection.through_reflection.name).any? { |source|
+              target = source.send(proxy_reflection.source_reflection.name)
+              target.respond_to?(:include?) ? target.include?(record) : target == record
+            } || @target.include?(record)
           else
             @target.include?(record)
           end

data/lib/active_record/associations/association_proxy.rb

@@ -174,10 +174,10 @@ module ActiveRecord
         # If the association is polymorphic the type of the owner is also set.
         def set_belongs_to_association_for(record)
           if @reflection.options[:as]
-            record["#{@reflection.options[:as]}_id"]   = @owner.id if @owner.persisted?
+            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
             record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
           else
-            if @owner.persisted?
+            unless @owner.new_record?
               primary_key = @reflection.options[:primary_key] || :id
               record[@reflection.primary_key_name] = @owner.send(primary_key)
             end
@@ -233,7 +233,7 @@ module ActiveRecord
         def load_target
           return nil unless defined?(@loaded)
 
-          if !loaded? and (@owner.persisted? || foreign_key_present)
+          if !loaded? and (!@owner.new_record? || foreign_key_present)
             @target = find_target
           end
 

data/lib/active_record/associations/belongs_to_association.rb

@@ -14,7 +14,7 @@ module ActiveRecord
         counter_cache_name = @reflection.counter_cache_column
 
         if record.nil?
-          if counter_cache_name && @owner.persisted?
+          if counter_cache_name && !@owner.new_record?
             @reflection.klass.decrement_counter(counter_cache_name, previous_record_id) if @owner[@reflection.primary_key_name]
           end
 
@@ -22,13 +22,13 @@ module ActiveRecord
         else
           raise_on_type_mismatch(record)
 
-          if counter_cache_name && @owner.persisted? && record.id != @owner[@reflection.primary_key_name]
+          if counter_cache_name && !@owner.new_record? && record.id != @owner[@reflection.primary_key_name]
             @reflection.klass.increment_counter(counter_cache_name, record.id)
             @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
           end
 
           @target = (AssociationProxy === record ? record.target : record)
-          @owner[@reflection.primary_key_name] = record_id(record) if record.persisted?
+          @owner[@reflection.primary_key_name] = record_id(record) unless record.new_record?
           @updated = true
         end
 

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -23,6 +23,10 @@ module ActiveRecord
         @updated
       end
 
+      def conditions
+       	@conditions ||= interpolate_sql(association_class.send(:sanitize_sql, @reflection.options[:conditions])) if @reflection.options[:conditions]
+      end
+
       private
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,7 +1,16 @@
+require 'active_support/deprecation'
+
 module ActiveRecord
   # = Active Record Has And Belongs To Many Association
   module Associations
     class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        super
+        if columns.size > 2
+          ActiveSupport::Deprecation.warn "Having additional attributes on the join table of a has_and_belongs_to_many association is deprecated and will be removed in Rails 3.1. Please use a has_many :through association instead."
+        end
+      end
+
       def create(attributes = {})
         create_record(attributes) { |record| insert_record(record) }
       end
@@ -34,7 +43,7 @@ module ActiveRecord
         end
 
         def insert_record(record, force = true, validate = true)
-          unless record.persisted?
+          if record.new_record?
             if force
               record.save!
             else

data/lib/active_record/associations/has_many_through_association.rb

@@ -59,7 +59,7 @@ module ActiveRecord
         end
 
         def insert_record(record, force = true, validate = true)
-          unless record.persisted?
+          if record.new_record?
             if force
               record.save!
             else

data/lib/active_record/associations/has_one_association.rb

@@ -35,18 +35,18 @@ module ActiveRecord
           if dependent? && !dont_save
             case @reflection.options[:dependent]
             when :delete
-              @target.delete if @target.persisted?
+              @target.delete unless @target.new_record?
               @owner.clear_association_cache
             when :destroy
-              @target.destroy if @target.persisted?
+              @target.destroy unless @target.new_record?
               @owner.clear_association_cache
             when :nullify
               @target[@reflection.primary_key_name] = nil
-              @target.save if @owner.persisted? && @target.persisted?
+              @target.save unless @owner.new_record? || @target.new_record?
             end
           else
             @target[@reflection.primary_key_name] = nil
-            @target.save if @owner.persisted? && @target.persisted?
+            @target.save unless @owner.new_record? || @target.new_record?
           end
         end
 
@@ -61,7 +61,7 @@ module ActiveRecord
         set_inverse_instance(obj, @owner)
         @loaded = true
 
-        unless !@owner.persisted? or obj.nil? or dont_save
+        unless @owner.new_record? or obj.nil? or dont_save
           return (obj.save ? self : false)
         else
           return (obj.nil? ? nil : self)
@@ -120,7 +120,7 @@ module ActiveRecord
           if replace_existing
             replace(record, true)
           else
-            record[@reflection.primary_key_name] = @owner.id if @owner.persisted?
+            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
             self.target = record
             set_inverse_instance(record, @owner)
           end

data/lib/active_record/associations/has_one_through_association.rb

@@ -21,7 +21,7 @@ module ActiveRecord
         if current_object
            new_value ? current_object.update_attributes(construct_join_attributes(new_value)) : current_object.destroy
         elsif new_value
-          unless @owner.persisted?
+          if @owner.new_record?
             self.target = new_value
             through_association = @owner.send(:association_instance_get, @reflection.through_reflection.name)
             through_association.build(construct_join_attributes(new_value))

data/lib/active_record/attribute_methods.rb

@@ -54,7 +54,7 @@ module ActiveRecord
 
     protected
       def attribute_method?(attr_name)
-        attr_name == 'id' || attributes.include?(attr_name)
+        attr_name == 'id' || (defined?(@attributes) && @attributes.include?(attr_name))
       end
   end
 end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -3,11 +3,10 @@ module ActiveRecord
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array or nil if
-      # the record is not persisted? or has just been destroyed.
+      # Returns this record's primary key value wrapped in an Array
+      # or nil if the record is a new_record?
       def to_key
-        key = send(self.class.primary_key)
-        [key] if key
+        new_record? ? nil : [ id ]
       end
 
       module ClassMethods

data/lib/active_record/attribute_methods/read.rb

@@ -75,7 +75,8 @@ module ActiveRecord
       def read_attribute(attr_name)
         attr_name = attr_name.to_s
         attr_name = self.class.primary_key if attr_name == 'id'
-        if !(value = @attributes[attr_name]).nil?
+        value = @attributes[attr_name]
+        unless value.nil?
           if column = column_for_attribute(attr_name)
             if unserializable_attribute?(attr_name, column)
               unserialize_attribute(attr_name)

data/lib/active_record/autosave_association.rb

@@ -89,7 +89,7 @@ module ActiveRecord
   #   post = Post.create(:title => 'ruby rocks')
   #   post.comments.create(:body => 'hello world')
   #   post.comments[0].body = 'hi everyone'
-  #   post.save # => saves both post and comment, with 'hi everyone' as title
+  #   post.save # => saves both post and comment, with 'hi everyone' as body
   #
   # Destroying one of the associated models as part of the parent's save action
   # is as simple as marking it for destruction:
@@ -208,7 +208,7 @@ module ActiveRecord
     # Returns whether or not this record has been changed in any way (including whether
     # any of its nested autosave associations are likewise changed)
     def changed_for_autosave?
-      !persisted? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
+      new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
     end
 
     private
@@ -222,7 +222,7 @@ module ActiveRecord
       elsif autosave
         association.target.find_all { |record| record.changed_for_autosave? }
       else
-        association.target.find_all { |record| !record.persisted? }
+        association.target.find_all { |record| record.new_record? }
       end
     end
 
@@ -248,7 +248,7 @@ module ActiveRecord
     # +reflection+.
     def validate_collection_association(reflection)
       if association = association_instance_get(reflection.name)
-        if records = associated_records_to_validate_or_save(association, !persisted?, reflection.options[:autosave])
+        if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
           records.each { |record| association_valid?(reflection, record) }
         end
       end
@@ -277,7 +277,7 @@ module ActiveRecord
     # Is used as a before_save callback to check while saving a collection
     # association whether or not the parent was a new record before saving.
     def before_save_collection_association
-      @new_record_before_save = !persisted?
+      @new_record_before_save = new_record?
       true
     end
 
@@ -299,7 +299,7 @@ module ActiveRecord
 
             if autosave && record.marked_for_destruction?
               association.destroy(record)
-            elsif autosave != false && (@new_record_before_save || !record.persisted?)
+            elsif autosave != false && (@new_record_before_save || record.new_record?)
               if autosave
                 saved = association.send(:insert_record, record, false, false)
               else
@@ -334,7 +334,7 @@ module ActiveRecord
           association.destroy
         else
           key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-          if autosave != false && (!persisted? || !association.persisted? || association[reflection.primary_key_name] != key || autosave)
+          if autosave != false && (new_record? || association.new_record? || association[reflection.primary_key_name] != key || autosave)
             association[reflection.primary_key_name] = key
             saved = association.save(:validate => !autosave)
             raise ActiveRecord::Rollback if !saved && autosave
@@ -354,7 +354,7 @@ module ActiveRecord
         if autosave && association.marked_for_destruction?
           association.destroy
         elsif autosave != false
-          saved = association.save(:validate => !autosave) if !association.persisted? || autosave
+          saved = association.save(:validate => !autosave) if association.new_record? || autosave
 
           if association.updated?
             association_id = association.send(reflection.options[:primary_key] || :id)

data/lib/active_record/base.rb

@@ -205,7 +205,7 @@ module ActiveRecord #:nodoc:
   #
   #   # No 'Winter' tag exists
   #   winter = Tag.find_or_initialize_by_name("Winter")
-  #   winter.persisted? # false
+  #   winter.new_record? # true
   #
   # To find by a subset of the attributes to be used for instantiating a new object, pass a hash instead of
   # a list of parameters.
@@ -1393,7 +1393,7 @@ MSG
       def initialize(attributes = nil)
         @attributes = attributes_from_column_definition
         @attributes_cache = {}
-        @persisted = false
+        @new_record = true
         @readonly = false
         @destroyed = false
         @marked_for_destruction = false
@@ -1428,7 +1428,7 @@ MSG
         clear_aggregation_cache
         clear_association_cache
         @attributes_cache = {}
-        @persisted = false
+        @new_record = true
         ensure_proper_type
 
         populate_with_current_scope_attributes
@@ -1447,8 +1447,7 @@ MSG
       def init_with(coder)
         @attributes = coder['attributes']
         @attributes_cache, @previously_changed, @changed_attributes = {}, {}, {}
-        @readonly = @destroyed = @marked_for_destruction = false
-        @persisted = true
+        @new_record = @readonly = @destroyed = @marked_for_destruction = false
         _run_find_callbacks
         _run_initialize_callbacks
       end
@@ -1489,7 +1488,7 @@ MSG
       #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
       def cache_key
         case
-        when !persisted?
+        when new_record?
           "#{self.class.model_name.cache_key}/new"
         when timestamp = self[:updated_at]
           "#{self.class.model_name.cache_key}/#{id}-#{timestamp.to_s(:number)}"
@@ -1618,9 +1617,8 @@ MSG
       # models are still comparable.
       def ==(comparison_object)
         comparison_object.equal?(self) ||
-          comparison_object.instance_of?(self.class) &&
-          id.present? &&
-          comparison_object.id == id
+          (comparison_object.instance_of?(self.class) &&
+            comparison_object.id == id && !comparison_object.new_record?)
       end
 
       # Delegates to ==
@@ -1665,7 +1663,7 @@ MSG
       # Returns the contents of the record as a nicely formatted string.
       def inspect
         attributes_as_nice_string = self.class.column_names.collect { |name|
-          if has_attribute?(name) || !persisted?
+          if has_attribute?(name) || new_record?
             "#{name}: #{attribute_for_inspect(name)}"
           end
         }.compact.join(", ")
@@ -1717,7 +1715,7 @@ MSG
             if include_readonly_attributes || (!include_readonly_attributes && !self.class.readonly_attributes.include?(name))
               value = read_attribute(name)
 
-              if value && self.class.serialized_attributes.key?(name)
+              if !value.nil? && self.class.serialized_attributes.key?(name)
                 value = YAML.dump value
               end
               attrs[self.class.arel_table[name]] = value

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -1,3 +1,4 @@
+require 'thread'
 require 'monitor'
 require 'set'
 require 'active_support/core_ext/module/synchronization'

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -26,11 +26,12 @@ module ActiveRecord
           when Float, Fixnum, Bignum    then value.to_s
           # BigDecimals need to be output in a non-normalized form and quoted.
           when BigDecimal               then value.to_s('F')
+          when Symbol                   then "'#{quote_string(value.to_s)}'"
           else
             if value.acts_like?(:date) || value.acts_like?(:time)
               "'#{quoted_date(value)}'"
             else
-              "'#{quote_string(value.to_s)}'"
+              "'#{quote_string(value.to_yaml)}'"
             end
         end
       end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -90,6 +90,11 @@ module ActiveRecord
         false
       end
 
+      # Does this adapter restrict the number of ids you can use in a list. Oracle has a limit of 1000.
+      def ids_in_list_limit
+        nil
+      end
+
       # QUOTING ==================================================
 
       # Override to return the quoted table name. Defaults to column quoting.

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -378,10 +378,7 @@ module ActiveRecord
       # REFERENTIAL INTEGRITY ====================================
 
       def supports_disable_referential_integrity?() #:nodoc:
-        version = query("SHOW server_version")[0][0].split('.')
-        version[0].to_i >= 8 && version[1].to_i >= 1
-      rescue
-        return false
+        postgresql_version >= 80100
       end
 
       def disable_referential_integrity #:nodoc:
@@ -897,8 +894,12 @@ module ActiveRecord
             else
               # Mimic PGconn.server_version behavior
               begin
-                query('SELECT version()')[0][0] =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
-                ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+                if query('SELECT version()')[0][0] =~ /PostgreSQL ([0-9.]+)/
+                  major, minor, tiny = $1.split(".")
+                  (major.to_i * 10000) + (minor.to_i * 100) + tiny.to_i
+                else
+                  0
+                end
               rescue
                 0
               end

data/lib/active_record/locking/optimistic.rb

@@ -109,7 +109,7 @@ module ActiveRecord
         def destroy #:nodoc:
           return super unless locking_enabled?
 
-          if persisted?
+          unless new_record?
             lock_col = self.class.locking_column
             previous_value = send(lock_col).to_i
 

data/lib/active_record/locking/pessimistic.rb

@@ -47,7 +47,7 @@ module ActiveRecord
       # or pass true for "FOR UPDATE" (the default, an exclusive row lock).  Returns
       # the locked record.
       def lock!(lock = true)
-        reload(:lock => lock) if persisted?
+        reload(:lock => lock) unless new_record?
         self
       end
     end

data/lib/active_record/nested_attributes.rb

@@ -385,11 +385,8 @@ module ActiveRecord
     # Updates a record with the +attributes+ or marks it for destruction if
     # +allow_destroy+ is +true+ and has_destroy_flag? returns +true+.
     def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
-      if has_destroy_flag?(attributes) && allow_destroy
-        record.mark_for_destruction
-      else
-        record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
-      end
+      record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
+      record.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
     end
 
     # Determines if a hash contains a truthy _destroy key.

data/lib/active_record/observer.rb

@@ -89,51 +89,29 @@ module ActiveRecord
   # singletons and that call instantiates and registers them.
   #
   class Observer < ActiveModel::Observer
-    class_attribute :observed_methods
-    self.observed_methods = [].freeze
 
     def initialize
       super
       observed_descendants.each { |klass| add_observer!(klass) }
     end
 
-    def self.method_added(method)
-      method = method.to_sym
-
-      if ActiveRecord::Callbacks::CALLBACKS.include?(method)
-        self.observed_methods += [method]
-        self.observed_methods.freeze
-      end
-    end
-
     protected
 
       def observed_descendants
         observed_classes.sum([]) { |klass| klass.descendants }
       end
 
-      def observe_callbacks?
-        self.class.observed_methods.any?
-      end
-
       def add_observer!(klass)
         super
-        define_callbacks klass if observe_callbacks?
+        define_callbacks klass
       end
 
       def define_callbacks(klass)
-        existing_methods = klass.instance_methods.map { |m| m.to_sym }
         observer = self
-        observer_name = observer.class.name.underscore.gsub('/', '__')
 
-        self.class.observed_methods.each do |method|
-          callback = :"_notify_#{observer_name}_for_#{method}"
-          unless existing_methods.include? callback
-            klass.send(:define_method, callback) do  # def _notify_user_observer_for_before_save
-              observer.update(method, self)          #   observer.update(:before_save, self)
-            end                                      # end
-            klass.send(method, callback)             # before_save :_notify_user_observer_for_before_save
-          end
+        ActiveRecord::Callbacks::CALLBACKS.each do |callback|
+          next unless respond_to?(callback)
+          klass.send(callback){|record| observer.send(callback, record)}
         end
       end
   end

data/lib/active_record/persistence.rb

@@ -4,7 +4,7 @@ module ActiveRecord
     # Returns true if this object hasn't been saved yet -- that is, a record
     # for the object doesn't exist in the data store yet; otherwise, returns false.
     def new_record?
-      !@persisted
+      @new_record
     end
 
     # Returns true if this object has been destroyed, otherwise returns false.
@@ -15,7 +15,7 @@ module ActiveRecord
     # Returns if the record is persisted, i.e. it's not a new record and it was
     # not destroyed.
     def persisted?
-      @persisted && !destroyed?
+      !(new_record? || destroyed?)
     end
 
     # :call-seq:
@@ -97,7 +97,7 @@ module ActiveRecord
       became = klass.new
       became.instance_variable_set("@attributes", @attributes)
       became.instance_variable_set("@attributes_cache", @attributes_cache)
-      became.instance_variable_set("@persisted", persisted?)
+      became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
       became
     end
@@ -243,7 +243,7 @@ module ActiveRecord
   private
     def create_or_update
       raise ReadOnlyRecord if readonly?
-      result = persisted? ? update : create
+      result = new_record? ? create : update
       result != false
     end
 
@@ -272,7 +272,7 @@ module ActiveRecord
 
       self.id ||= new_id
 
-      @persisted = true
+      @new_record = false
       id
     end
 

data/lib/active_record/reflection.rb

@@ -207,7 +207,15 @@ module ActiveRecord
       end
 
       def association_foreign_key
-        @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      def association_primary_key
+        @association_primary_key ||= options[:primary_key] || klass.primary_key
+      end
+
+      def active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || active_record.primary_key
       end
 
       def counter_cache_column

data/lib/active_record/relation.rb

@@ -376,7 +376,7 @@ module ActiveRecord
 
     def references_eager_loaded_tables?
       # always convert table names to downcase as in Oracle quoted table names are in uppercase
-      joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.map{ |t| t.downcase }.uniq
+      joined_tables = (tables_in_string(arel.join_sql) + [table.name, table.table_alias]).compact.map{ |t| t.downcase }.uniq
       (tables_in_string(to_sql) - joined_tables).any?
     end
 

data/lib/active_record/relation/calculations.rb

@@ -166,7 +166,7 @@ module ActiveRecord
       if operation == "count"
         column_name ||= (select_for_count || :all)
 
-        if arel.joins(arel) =~ /LEFT OUTER/i
+        if arel.join_sql =~ /LEFT OUTER/i
           distinct = true
           column_name = @klass.primary_key if column_name == :all
         end
@@ -208,14 +208,19 @@ module ActiveRecord
     end
 
     def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
-      group_attr      = @group_values.first
-      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_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.primary_key_name : group_attr)
+      group_aliases = []
+      group_columns = {}
+      
+      group_fields.each do |field|
+        group_aliases << column_alias_for(field)
+        group_columns[column_alias_for(field)] = column_for(field)
+      end
 
-      group = @klass.connection.adapter_name == 'FrontBase' ? group_alias : group_field
+      group = @klass.connection.adapter_name == 'FrontBase' ? group_aliases : group_fields
 
       if operation == 'count' && column_name == :all
         aggregate_alias = 'count_all'
@@ -223,22 +228,21 @@ module ActiveRecord
         aggregate_alias = column_alias_for(operation, column_name)
       end
 
-      relation = except(:group).group(group)
-      relation.select_values = [
-        operation_over_aggregate_column(aggregate_column(column_name), operation, distinct).as(aggregate_alias),
-        "#{group_field} AS #{group_alias}"
-      ]
+      relation = except(:group).group(group.join(','))
+      relation.select_values = [ operation_over_aggregate_column(aggregate_column(column_name), operation, distinct).as(aggregate_alias) ]
+      group_fields.each_index{ |i| relation.select_values << "#{group_fields[i]} AS #{group_aliases[i]}" }
 
       calculated_data = @klass.connection.select_all(relation.to_sql)
 
       if association
-        key_ids     = calculated_data.collect { |row| row[group_alias] }
+        key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
         key_records = association.klass.base_class.find(key_ids)
         key_records = Hash[key_records.map { |r| [r.id, r] }]
       end
 
       ActiveSupport::OrderedHash[calculated_data.map do |row|
-        key = type_cast_calculated_value(row[group_alias], group_column)
+        key   = group_aliases.map{|group_alias| type_cast_calculated_value(row[group_alias], group_columns[group_alias])}
+        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]
@@ -269,15 +273,11 @@ module ActiveRecord
     end
 
     def type_cast_calculated_value(value, column, operation = nil)
-      if value.is_a?(String) || value.nil?
-        case operation
-          when 'count'   then value.to_i
-          when 'sum'     then type_cast_using_column(value || '0', column)
-          when 'average' then value.try(:to_d)
-          else type_cast_using_column(value, column)
-        end
-      else
-        type_cast_using_column(value, column)
+      case operation
+        when 'count'   then value.to_i
+        when 'sum'     then type_cast_using_column(value || '0', column)
+        when 'average' then value.try(:to_d)
+        else type_cast_using_column(value, column)
       end
     end
 

data/lib/active_record/relation/finder_methods.rb

@@ -194,7 +194,7 @@ module ActiveRecord
 
     def construct_relation_for_association_calculations
       including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.joins(arel))
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.join_sql)
       relation = except(:includes, :eager_load, :preload)
       apply_join_dependency(relation, join_dependency)
     end

data/lib/active_record/relation/predicate_builder.rb

@@ -25,13 +25,13 @@ module ActiveRecord
           case value
           when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
             values = value.to_a.map { |x|
-              x.respond_to?(:quoted_id) ? x.quoted_id : x
+              x.is_a?(ActiveRecord::Base) ? x.id : x
             }
             attribute.in(values)
           when Range, Arel::Relation
             attribute.in(value)
           when ActiveRecord::Base
-            attribute.eq(value.quoted_id)
+            attribute.eq(value.id)
           when Class
             # FIXME: I think we need to deprecate this behavior
             attribute.eq(value.name)

data/lib/active_record/relation/query_methods.rb

@@ -143,7 +143,7 @@ module ActiveRecord
         "#{@klass.table_name}.#{@klass.primary_key} DESC" :
         reverse_sql_order(order_clause)
 
-      relation.order(Arel::SqlLiteral.new(order))
+      relation.order(Arel.sql(order))
     end
 
     def arel
@@ -168,7 +168,7 @@ module ActiveRecord
         arel.join(join)
       end
 
-      arel.joins(arel)
+      arel.join_sql
     end
 
     def build_arel
@@ -176,10 +176,7 @@ module ActiveRecord
 
       arel = build_joins(arel, @joins_values) unless @joins_values.empty?
 
-      (@where_values - ['']).uniq.each do |where|
-        where = Arel.sql(where) if String === where
-        arel = arel.where(Arel::Nodes::Grouping.new(where))
-      end
+      arel = collapse_wheres(arel, (@where_values - ['']).uniq)
 
       arel = arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
 
@@ -200,6 +197,27 @@ module ActiveRecord
 
     private
 
+    def collapse_wheres(arel, wheres)
+      equalities = wheres.grep(Arel::Nodes::Equality)
+
+      groups = equalities.group_by do |equality|
+        equality.left
+      end
+
+      groups.each do |_, eqls|
+        test = eqls.inject(eqls.shift) do |memo, expr|
+          memo.or(expr)
+        end
+        arel = arel.where(test)
+      end
+
+      (wheres - equalities).each do |where|
+        where = Arel.sql(where) if String === where
+        arel = arel.where(Arel::Nodes::Grouping.new(where))
+      end
+      arel
+    end
+
     def build_where(opts, other = [])
       case opts
       when String, Array

data/lib/active_record/session_store.rb

@@ -228,7 +228,7 @@ module ActiveRecord
         @session_id     = attributes[:session_id]
         @data           = attributes[:data]
         @marshaled_data = attributes[:marshaled_data]
-        @persisted      = !@marshaled_data.nil?
+        @new_record     = @marshaled_data.nil?
       end
 
       # Lazy-unmarshal session state.
@@ -252,8 +252,8 @@ module ActiveRecord
         marshaled_data = self.class.marshal(data)
         connect        = connection
 
-        unless @persisted
-          @persisted = true
+        if @new_record
+          @new_record = false
           connect.update <<-end_sql, 'Create session'
             INSERT INTO #{table_name} (
               #{connect.quote_column_name(session_id_column)},
@@ -272,7 +272,7 @@ module ActiveRecord
       end
 
       def destroy
-        return unless @persisted
+        return if @new_record
 
         connect = connection
         connect.delete <<-end_sql, 'Destroy session'

data/lib/active_record/timestamp.rb

@@ -65,7 +65,7 @@ module ActiveRecord
     end
 
     def timestamp_attributes_for_update_in_model
-      timestamp_attributes_for_update.select { |c| respond_to?(c) }
+      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
     end
 
     def timestamp_attributes_for_update #:nodoc:

data/lib/active_record/transactions.rb

@@ -130,7 +130,7 @@ module ActiveRecord
     #
     # +transaction+ calls can be nested. By default, this makes all database
     # statements in the nested transaction block become part of the parent
-    # transaction. For example:
+    # transaction. For example, the following behavior may be surprising:
     #
     #   User.transaction do
     #     User.create(:username => 'Kotori')
@@ -140,12 +140,15 @@ module ActiveRecord
     #     end
     #   end
     #
-    #   User.find(:all)  # => empty
+    # creates both "Kotori" and "Nemu". Reason is the <tt>ActiveRecord::Rollback</tt>
+    # exception in the nested block does not issue a ROLLBACK. Since these exceptions
+    # are captured in transaction blocks, the parent block does not see it and the
+    # real transaction is committed.
     #
-    # It is also possible to requires a sub-transaction by passing
-    # <tt>:requires_new => true</tt>. If anything goes wrong, the
-    # database rolls back to the beginning of the sub-transaction
-    # without rolling back the parent transaction. For example:
+    # In order to get a ROLLBACK for the nested transaction you may ask for a real
+    # sub-transaction by passing <tt>:requires_new => true</tt>. If anything goes wrong,
+    # the database rolls back to the beginning of the sub-transaction without rolling
+    # back the parent transaction. If we add it to the previous example:
     #
     #   User.transaction do
     #     User.create(:username => 'Kotori')
@@ -155,12 +158,12 @@ module ActiveRecord
     #     end
     #   end
     #
-    #   User.find(:all)  # => Returns only Kotori
+    # only "Kotori" is created. (This works on MySQL and PostgreSQL, but not on SQLite3.)
     #
     # Most databases don't support true nested transactions. At the time of
     # writing, the only database that we're aware of that supports true nested
     # transactions, is MS-SQL. Because of this, Active Record emulates nested
-    # transactions by using savepoints. See
+    # transactions by using savepoints on MySQL and PostgreSQL. See
     # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
     # for more information about savepoints.
     #
@@ -242,7 +245,7 @@ module ActiveRecord
       with_transaction_returning_status { super }
     end
 
-    # Reset id and @persisted if the transaction rolls back.
+    # Reset id and @new_record if the transaction rolls back.
     def rollback_active_record_state!
       remember_transaction_record_state
       yield
@@ -297,9 +300,9 @@ module ActiveRecord
     # Save the new record state and id of a record so it can be restored later if a transaction fails.
     def remember_transaction_record_state #:nodoc
       @_start_transaction_state ||= {}
-      unless @_start_transaction_state.include?(:persisted)
+      unless @_start_transaction_state.include?(:new_record)
         @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
-        @_start_transaction_state[:persisted] = @persisted
+        @_start_transaction_state[:new_record] = @new_record
       end
       unless @_start_transaction_state.include?(:destroyed)
         @_start_transaction_state[:destroyed] = @destroyed
@@ -323,7 +326,7 @@ module ActiveRecord
           restore_state = remove_instance_variable(:@_start_transaction_state)
           if restore_state
             @attributes = @attributes.dup if @attributes.frozen?
-            @persisted = restore_state[:persisted]
+            @new_record = restore_state[:new_record]
             @destroyed = restore_state[:destroyed]
             if restore_state[:id]
               self.id = restore_state[:id]
@@ -345,11 +348,11 @@ module ActiveRecord
     def transaction_include_action?(action) #:nodoc
       case action
       when :create
-        transaction_record_state(:new_record) || !transaction_record_state(:persisted)
+        transaction_record_state(:new_record)
       when :destroy
         destroyed?
       when :update
-        !(transaction_record_state(:new_record) || !transaction_record_state(:persisted) || destroyed?)
+        !(transaction_record_state(:new_record) || destroyed?)
       end
     end
   end

data/lib/active_record/validations.rb

@@ -51,7 +51,7 @@ module ActiveRecord
 
     # Runs all the specified validations and returns true if no errors were added otherwise false.
     def valid?(context = nil)
-      context ||= (persisted? ? :update : :create)
+      context ||= (new_record? ? :create : :update)
       output = super(context)
 
       deprecated_callback_method(:validate)

data/lib/active_record/validations/uniqueness.rb

@@ -31,7 +31,7 @@ module ActiveRecord
           relation = relation.where(scope_item => scope_value)
         end
 
-        if record.persisted?
+        unless record.new_record?
           # TODO : This should be in Arel
           relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
         end

data/lib/active_record/version.rb

@@ -2,8 +2,9 @@ module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = 1
-        
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    TINY  = 4
+    PRE   = "rc1"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord
 version: !ruby/object:Gem::Version 
-  hash: 1
-  prerelease: false
+  hash: 977940590
+  prerelease: true
   segments: 
   - 3
   - 0
-  - 3
-  version: 3.0.3
+  - 4
+  - rc1
+  version: 3.0.4.rc1
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -15,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-16 00:00:00 -06:00
+date: 2011-01-31 00:00:00 +13:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +27,13 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 1
+        hash: 977940590
         segments: 
         - 3
         - 0
-        - 3
-        version: 3.0.3
+        - 4
+        - rc1
+        version: 3.0.4.rc1
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -42,12 +44,13 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 1
+        hash: 977940590
         segments: 
         - 3
         - 0
-        - 3
-        version: 3.0.3
+        - 4
+        - rc1
+        version: 3.0.4.rc1
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -208,12 +211,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: activerecord