activerecord 1.13.0 → 1.13.1

data/CHANGELOG

@@ -1,3 +1,94 @@
+*1.13.1* (December 7th, 2005)
+
+* MySQL: more robust test for nullified result hashes.  #3124 [Stefan Kaes]
+
+* SQLite: find database file when RAILS_ROOT is a symlink.  #3116 [anna@wota.jp]
+
+* Reloading an instance refreshes its aggregations as well as its associations.  #3024 [François Beausolei]
+
+* Fixed that using :include together with :conditions array in Base.find would cause NoMethodError #2887 [Paul Hammmond]
+
+* PostgreSQL: more robust sequence name discovery.  #3087 [Rick Olson]
+
+* Oracle: use syntax compatible with Oracle 8.  #3131 [Michael Schoen]
+
+* MySQL: work around ruby-mysql/mysql-ruby inconsistency with mysql.stat.  Eliminate usage of mysql.ping because it doesn't guarantee reconnect.  Explicitly close and reopen the connection instead.  [Jeremy Kemper]
+
+* When AbstractAdapter#log rescues an exception, attempt to detect and reconnect to an inactive database connection.  Connection adapter must respond to the active? and reconnect! instance methods.  Initial support for PostgreSQL, MySQL, and SQLite.  Make certain that all statements which may need reconnection are performed within a logged block: for example, this means no avoiding log(sql, name) { } if @logger.nil?  [Jeremy Kemper]
+
+* Firebird: active? and reconnect! methods for handling stale connections.  #428 [Ken Kunz <kennethkunz@gmail.com>]
+
+* Firebird: updated for FireRuby 0.4.0.  #3009 [Ken Kunz <kennethkunz@gmail.com>]
+
+* Introducing the Firebird adapter.  Quote columns and use attribute_condition more consistently.  Setup guide: http://wiki.rubyonrails.com/rails/pages/Firebird+Adapter  #1874 [Ken Kunz <kennethkunz@gmail.com>]
+
+* MySQL and PostgreSQL: active? compatibility with the pure-Ruby driver.  #428 [Jeremy Kemper]
+
+* Oracle: active? check pings the database rather than testing the last command status.  #428 [Michael Schoen]
+
+* SQLServer: resolve column aliasing/quoting collision when using limit or offset in an eager find.  #2974 [kajism@yahoo.com]
+
+* Reloading a model doesn't lose track of its connection.  #2996 [junk@miriamtech.com, Jeremy Kemper]
+
+* Fixed bug where using update_attribute after pushing a record to a habtm association of the object caused duplicate rows in the join table. #2888 [colman@rominato.com, Florian Weber, Michael Schoen]
+
+* MySQL: introduce :encoding option to specify the character set for client, connection, and results.  Only available for MySQL 4.1 and later with the mysql-ruby driver.  Do SHOW CHARACTER SET in mysql client to see available encodings.  #2975 [Shugo Maeda]
+
+* Add tasks to create, drop and rebuild the MySQL and PostgreSQL test  databases. [Marcel Molina Jr.]
+
+* Correct boolean handling in generated reader methods.  #2945 [don.park@gmail.com, Stefan Kaes]
+
+* Don't generate read methods for columns whose names are not valid ruby method names.  #2946 [Stefan Kaes]
+
+* Document :force option to create_table.  #2921 [Blair Zajac <blair@orcaware.com>]
+
+* Don't add the same conditions twice in has_one finder sql.  #2916 [Jeremy Evans]
+
+* Rename Version constant to VERSION. #2802 [Marcel Molina Jr.]
+
+* SQLServer: insert uses given primary key value if not nil rather than SELECT @@IDENTITY.  #2866 [kajism@yahoo.com, Tom Ward <tom@popdog.net>]
+
+* Correct documentation for Base.delete_all.  #1568 [Newhydra]
+
+* Oracle: test case for column default parsing.  #2788 [Michael Schoen <schoenm@earthlink.net>]
+
+* Update documentation for Migrations.  #2861 [Tom Werner <tom@cube6media.com>]
+
+* Oracle: Much faster column reflection.  #2848 [Michael Schoen <schoenm@earthlink.net>]
+
+* Base.reset_sequence_name analogous to reset_table_name (mostly useful for testing).  Base.define_attr_method allows nil values.  [Jeremy Kemper]
+
+* PostgreSQL: smarter sequence name defaults, stricter last_insert_id, warn on pk without sequence.  [Jeremy Kemper]
+
+* PostgreSQL: correctly discover custom primary key sequences.  #2594 [Blair Zajac <blair@orcaware.com>, meadow.nnick@gmail.com, Jeremy Kemper]
+
+* SQLServer: don't report limits for unsupported field types.  #2835 [Ryan Tomayko]
+
+* Include the Enumerable module in ActiveRecord::Errors.  [Rick Bradley <rick@rickbradley.com>]
+
+* Add :group option, correspond to GROUP BY, to the find method and to the has_many association.  #2818 [rubyonrails@atyp.de]
+
+* Don't cast nil or empty strings to a dummy date.  #2789 [Rick Bradley <rick@rickbradley.com>]
+
+* acts_as_list plays nicely with inheritance by remembering the class which declared it.  #2811 [rephorm@rephorm.com]
+
+* Fix sqlite adaptor's detection of missing dbfile or database declaration. [Nicholas Seckar]
+
+* Fixed acts_as_list for definitions without an explicit :order #2803 [jonathan@bluewire.net.nz]
+
+* Upgrade bundled ruby-mysql 0.2.4 with mysql411 shim (see #440) to ruby-mysql 0.2.6 with a patchset for 4.1 protocol support.  Local change [301] is now a part of the main driver; reapplied local change [2182].  Removed GC.start from Result.free.  [tommy@tmtm.org, akuroda@gmail.com, Doug Fales <doug.fales@gmail.com>, Jeremy Kemper]
+
+* Correct handling of complex order clauses with SQL Server limit emulation.  #2770 [Tom Ward <tom@popdog.net>, Matt B.]
+
+* Correct whitespace problem in Oracle default column value parsing.  #2788 [rick@rickbradley.com]
+
+* Destroy associated has_and_belongs_to_many records after all before_destroy callbacks but before destroy.  This allows you to act on the habtm association as you please while preserving referential integrity.  #2065 [larrywilliams1@gmail.com, sam.kirchmeier@gmail.com, elliot@townx.org, Jeremy Kemper]
+
+* Deprecate the old, confusing :exclusively_dependent option in favor of :dependent => :delete_all.  [Jeremy Kemper]
+
+* More compatible Oracle column reflection.  #2771 [Ryan Davis <ryand-ruby@zenspider.com>, Michael Schoen <schoenm@earthlink.net>]
+
+
 *1.13.0* (November 7th, 2005)
 
 * Fixed faulty regex in get_table_name method (SQLServerAdapter) #2639 [Ryan Tomayko]

data/lib/active_record.rb

@@ -66,11 +66,11 @@ ActiveRecord::Base.class_eval do
 end
 
 unless defined?(RAILS_CONNECTION_ADAPTERS)
-  RAILS_CONNECTION_ADAPTERS = %w(mysql postgresql sqlite sqlserver db2 oci)
+  RAILS_CONNECTION_ADAPTERS = %w(mysql postgresql sqlite firebird sqlserver db2 oci)
 end
 
 RAILS_CONNECTION_ADAPTERS.each do |adapter|
-  require "active_record/connection_adapters/#{adapter}_adapter"
+  require "active_record/connection_adapters/" + adapter + "_adapter"
 end
 
 require 'active_record/query_cache'

data/lib/active_record/acts/list.rb

@@ -54,6 +54,10 @@ module ActiveRecord
           class_eval <<-EOV
             include ActiveRecord::Acts::List::InstanceMethods
 
+            def acts_as_list_class
+              ::#{self.name}
+            end
+            
             def position_column
               '#{configuration[:column]}'
             end
@@ -78,7 +82,7 @@ module ActiveRecord
         def move_lower
           return unless lower_item
 
-          self.class.transaction do
+          acts_as_list_class.transaction do
             lower_item.decrement_position
             increment_position
           end
@@ -87,7 +91,7 @@ module ActiveRecord
         def move_higher
           return unless higher_item
 
-          self.class.transaction do
+          acts_as_list_class.transaction do
             higher_item.increment_position
             decrement_position
           end
@@ -95,7 +99,7 @@ module ActiveRecord
         
         def move_to_bottom
           return unless in_list?
-          self.class.transaction do
+          acts_as_list_class.transaction do
             decrement_positions_on_lower_items
             assume_bottom_position
           end
@@ -103,7 +107,7 @@ module ActiveRecord
         
         def move_to_top
           return unless in_list?
-          self.class.transaction do
+          acts_as_list_class.transaction do
             increment_positions_on_higher_items
             assume_top_position
           end
@@ -135,14 +139,14 @@ module ActiveRecord
         
         def higher_item
           return nil unless in_list?
-          self.class.find(:first, :conditions =>
+          acts_as_list_class.find(:first, :conditions =>
             "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
           )
         end
 
         def lower_item
           return nil unless in_list?
-          self.class.find(:first, :conditions =>
+          acts_as_list_class.find(:first, :conditions =>
             "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
           )
         end
@@ -171,7 +175,7 @@ module ActiveRecord
           def bottom_item(except = nil)
             conditions = scope_condition
             conditions = "#{conditions} AND id != #{except.id}" if except
-            self.class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
+            acts_as_list_class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
           end
 
           def assume_bottom_position
@@ -184,7 +188,7 @@ module ActiveRecord
 
           # This has the effect of moving all the higher items up one.
           def decrement_positions_on_higher_items(position)
-            self.class.update_all(
+            acts_as_list_class.update_all(
               "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"
             )
           end
@@ -192,7 +196,7 @@ module ActiveRecord
           # This has the effect of moving all the lower items up one.
           def decrement_positions_on_lower_items
             return unless in_list?
-            self.class.update_all(
+            acts_as_list_class.update_all(
               "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
             )
           end
@@ -200,20 +204,20 @@ module ActiveRecord
           # This has the effect of moving all the higher items down one.
           def increment_positions_on_higher_items
             return unless in_list?
-            self.class.update_all(
+            acts_as_list_class.update_all(
               "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
             )
           end
 
           # This has the effect of moving all the lower items down one.
           def increment_positions_on_lower_items(position)
-            self.class.update_all(
+            acts_as_list_class.update_all(
               "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{position}"
            )
           end
 
           def increment_positions_on_all_items
-            self.class.update_all(
+            acts_as_list_class.update_all(
               "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
             )
           end

data/lib/active_record/acts/tree.rb

@@ -49,10 +49,10 @@ module ActiveRecord
 
           module_eval <<-END
             def self.roots
-              self.find(:all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => "#{configuration[:order]}")
+              self.find(:all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
             end
             def self.root
-              self.find(:first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => "#{configuration[:order]}")
+              self.find(:first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
             end
           END
 

data/lib/active_record/aggregations.rb

@@ -5,6 +5,12 @@ module ActiveRecord
       base.extend(ClassMethods)
     end
 
+    def clear_aggregation_cache #:nodoc:
+      self.class.reflect_on_all_aggregations.to_a.each do |assoc|
+        instance_variable_set "@#{assoc.name}", nil
+      end unless self.new_record?
+    end
+
     # Active Record implements aggregation through a macro-like class method called +composed_of+ for representing attributes 
     # as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is]
     # composed of [an] address". Each call to the macro adds a description of how the value objects are created from the 

data/lib/active_record/associations.rb

@@ -307,14 +307,18 @@ module ActiveRecord
       #   sql fragment, such as "price > 5 AND name LIKE 'B%'".
       # * <tt>:order</tt>       - specify the order in which the associated objects are returned as a "ORDER BY" sql fragment,
       #   such as "last_name, first_name DESC"
+      # * <tt>:group</tt>       - specify the attribute by which the associated objects are returned as a "GROUP BY" sql fragment,
+      #   such as "category"      
       # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default this is guessed to be the name
       #   of this class in lower-case and "_id" suffixed. So a +Person+ class that makes a has_many association will use "person_id"
       #   as the default foreign_key.
       # * <tt>:dependent</tt>   - if set to :destroy (or true) all the associated objects are destroyed
-      #   alongside this object. Also accepts :nullify which will set the associated object's foreign key
-      #   field to NULL.
+      #   alongside this object by calling their destroy method.  If set to :delete_all all associated
+      #   objects are deleted *without* calling their destroy method.  If set to :nullify all associated
+      #   objects' foreign keys are set to NULL *without* calling their save callbacks.
       #   May not be set if :exclusively_dependent is also set.
-      # * <tt>:exclusively_dependent</tt>   - if set to true all the associated object are deleted in one SQL statement without having their
+      # * <tt>:exclusively_dependent</tt>   - Deprecated; equivalent to :dependent => :delete_all. If set to true all
+      #   the associated object are deleted in one SQL statement without having their
       #   before_destroy callback run. This should only be used on associations that depend solely on this class and don't need to do any
       #   clean-up in before_destroy. The upside is that it's much faster, especially if there's a counter_cache involved.
       #   May not be set if :dependent is also set.
@@ -339,7 +343,8 @@ module ActiveRecord
         options.assert_valid_keys(
           :foreign_key, :class_name, :exclusively_dependent, :dependent, 
           :conditions, :order, :include, :finder_sql, :counter_sql, 
-          :before_add, :after_add, :before_remove, :after_remove, :extend
+          :before_add, :after_add, :before_remove, :after_remove, :extend,
+          :group
         )
 
         options[:extend] = create_extension_module(association_id, extension) if block_given?
@@ -350,24 +355,28 @@ module ActiveRecord
         require_association_class(association_class_name)
 
         raise ArgumentError, ':dependent and :exclusively_dependent are mutually exclusive options.  You may specify one or the other.' if options[:dependent] and options[:exclusively_dependent]
-          
+
+        if options[:exclusively_dependent]
+          options[:dependent] = :delete_all
+          #warn "The :exclusively_dependent option is deprecated.  Please use :dependent => :delete_all instead.")
+        end
+
         # See HasManyAssociation#delete_records.  Dependent associations
         # delete children, otherwise foreign key is set to NULL.
         case options[:dependent]
           when :destroy, true  
             module_eval "before_destroy '#{association_name}.each { |o| o.destroy }'"
+          when :delete_all
+            module_eval "before_destroy { |record| #{association_class_name}.delete_all(%(#{association_class_primary_key_name} = \#{record.quoted_id})) }"
           when :nullify
             module_eval "before_destroy { |record| #{association_class_name}.update_all(%(#{association_class_primary_key_name} = NULL),  %(#{association_class_primary_key_name} = \#{record.quoted_id})) }"
           when nil, false
             # pass
           else
-            raise ArgumentError, 'The :dependent option expects either true, :destroy or :nullify' 
-        end   
-        
-        if options[:exclusively_dependent]
-          module_eval "before_destroy { |record| #{association_class_name}.delete_all(%(#{association_class_primary_key_name} = \#{record.quoted_id})) }"
+            raise ArgumentError, 'The :dependent option expects either true, :destroy, :delete_all, or :nullify' 
         end
 
+
         add_multiple_associated_save_callbacks(association_name)
         add_association_callbacks(association_name, options)
 
@@ -646,8 +655,17 @@ module ActiveRecord
       
         collection_accessor_methods(association_name, association_class_name, association_class_primary_key_name, options, HasAndBelongsToManyAssociation)
 
-        before_destroy_sql = "DELETE FROM #{options[:join_table]} WHERE #{association_class_primary_key_name} = \\\#{self.quoted_id}"
-        module_eval(%{before_destroy "self.connection.delete(%{#{before_destroy_sql}})"}) # "
+        # Don't use a before_destroy callback since users' before_destroy
+        # callbacks will be executed after the association is wiped out.
+        old_method = "destroy_without_habtm_shim_for_#{association_name}"
+        class_eval <<-end_eval
+          alias_method :#{old_method}, :destroy_without_callbacks
+          def destroy_without_callbacks
+            #{association_name}.clear
+            #{old_method}
+          end
+        end_eval
+
         add_association_callbacks(association_name, options)
         
         # deprecated api
@@ -791,6 +809,9 @@ module ActiveRecord
               records_to_save.each { |record| association.send(:insert_record, record) }
               association.send(:construct_sql)   # reconstruct the SQL queries now that we know the owner's id
             end
+
+            @new_record_before_save = false
+            true
           end_eval
 
           # Doesn't use after_save as that would save associations added in after_create/after_update twice
@@ -959,9 +980,10 @@ module ActiveRecord
         end
 
         def include_eager_conditions?(options)
-          return false unless options[:conditions]
-          
-          options[:conditions].scan(/ ([^.]+)\.[^.]+ /).flatten.any? do |condition_table_name| 
+          conditions = options[:conditions]
+          return false unless conditions
+          conditions = conditions.first if conditions.is_a?(Array)
+          conditions.scan(/(\w+)\.\w+/).flatten.any? do |condition_table_name|
             condition_table_name != table_name
           end
         end
@@ -981,7 +1003,7 @@ module ActiveRecord
         end
 
         def column_aliases(schema_abbreviations)
-          schema_abbreviations.collect { |cn, tc| "#{tc.join(".")} AS #{cn}" }.join(", ")
+          schema_abbreviations.collect { |cn, tc| "#{tc[0]}.#{connection.quote_column_name tc[1]} AS #{cn}" }.join(", ")
         end
 
         def association_join(reflection)

data/lib/active_record/associations/has_many_association.rb

@@ -113,7 +113,8 @@ module ActiveRecord
               :order      => @options[:order], 
               :limit      => @options[:limit],
               :joins      => @options[:joins],
-              :include    => @options[:include]
+              :include    => @options[:include],
+              :group      => @options[:group]
             )
           end
         end

data/lib/active_record/associations/has_one_association.rb

@@ -65,7 +65,7 @@ module ActiveRecord
         end
 
         def construct_sql
-          @finder_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}#{@options[:conditions] ? " AND " + @options[:conditions] : ""}"
+          @finder_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
           @finder_sql << " AND (#{sanitize_sql(@options[:conditions])})" if @options[:conditions]
           @finder_sql
         end

data/lib/active_record/base.rb

@@ -243,24 +243,6 @@ module ActiveRecord #:nodoc:
     # on to any new database connections made and which can be retrieved on both a class and instance level by calling +logger+.
     cattr_accessor :logger
 
-    # Returns the connection currently associated with the class. This can
-    # also be used to "borrow" the connection to do database work unrelated
-    # to any of the specific Active Records.
-    def self.connection
-      if allow_concurrency
-        retrieve_connection
-      else
-        @connection ||= retrieve_connection
-      end
-    end
-
-    # Returns the connection currently associated with the class. This can
-    # also be used to "borrow" the connection to do database work that isn't
-    # easily done without going straight to SQL.
-    def connection
-      self.class.connection
-    end
-
     def self.inherited(child) #:nodoc:
       @@subclasses[self] ||= []
       @@subclasses[self] << child
@@ -363,6 +345,7 @@ module ActiveRecord #:nodoc:
       #
       # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro.
       # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name".
+      # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
       # * <tt>:limit</tt>: An integer determining the limit on the number of rows that should be returned.
       # * <tt>:offset</tt>: An integer determining the offset from where the rows should be fetched. So at 5, it would skip the first 4 rows.
       # * <tt>:joins</tt>: An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
@@ -391,6 +374,7 @@ module ActiveRecord #:nodoc:
       #   Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
       #   Person.find(:all, :offset => 10, :limit => 10)
       #   Person.find(:all, :include => [ :account, :friends ])
+      #   Person.find(:all, :group => "category")
       def find(*args)
         options = extract_options_from_args!(args)
 
@@ -511,7 +495,7 @@ module ActiveRecord #:nodoc:
 
       # Deletes all the records that match the +condition+ without instantiating the objects first (and hence not
       # calling the destroy method). Example:
-      #   Post.destroy_all "person_id = 5 AND (category = 'Something' OR category = 'Else')"
+      #   Post.delete_all "person_id = 5 AND (category = 'Something' OR category = 'Else')"
       def delete_all(conditions = nil)
         sql = "DELETE FROM #{table_name} "
         add_conditions!(sql, conditions)
@@ -644,9 +628,16 @@ module ActiveRecord #:nodoc:
         "type"
       end
 
-      # Default sequence_name.  Use set_sequence_name to override.
+      # Lazy-set the sequence name to the connection's default.  This method
+      # is only ever called once since set_sequence_name overrides it.
       def sequence_name
-        connection.default_sequence_name(table_name, primary_key)
+        reset_sequence_name
+      end
+
+      def reset_sequence_name
+        default = connection.default_sequence_name(table_name, primary_key)
+        set_sequence_name(default)
+        default
       end
 
       # Sets the table name to use to the given value, or (if the value
@@ -697,9 +688,11 @@ module ActiveRecord #:nodoc:
       # given block. This is required for Oracle and is useful for any
       # database which relies on sequences for primary key generation.
       #
-      # Setting the sequence name when using other dbs will have no effect.
-      # If a sequence name is not explicitly set when using Oracle, it will
-      # default to the commonly used pattern of: #{table_name}_seq
+      # If a sequence name is not explicitly set when using Oracle or Firebird,
+      # it will default to the commonly used pattern of: #{table_name}_seq
+      #
+      # If a sequence name is not explicitly set when using PostgreSQL, it
+      # will discover the sequence corresponding to your primary key for you.
       #
       # Example:
       #
@@ -926,6 +919,7 @@ module ActiveRecord #:nodoc:
           sql  = "SELECT #{options[:select] || '*'} FROM #{table_name} "
           add_joins!(sql, options)
           add_conditions!(sql, options[:conditions])
+          sql << " GROUP BY #{options[:group]} " if options[:group]
           sql << " ORDER BY #{options[:order]} " if options[:order]
           add_limit!(sql, options)
           sql
@@ -952,8 +946,9 @@ module ActiveRecord #:nodoc:
         end
 
         def type_condition
-          type_condition = subclasses.inject("#{table_name}.#{inheritance_column} = '#{name.demodulize}' ") do |condition, subclass|
-            condition << "OR #{table_name}.#{inheritance_column} = '#{subclass.name.demodulize}' "
+          quoted_inheritance_column = connection.quote_column_name(inheritance_column)
+          type_condition = subclasses.inject("#{table_name}.#{quoted_inheritance_column} = '#{name.demodulize}' ") do |condition, subclass|
+            condition << "OR #{table_name}.#{quoted_inheritance_column} = '#{subclass.name.demodulize}' "
           end
 
           " (#{type_condition}) "
@@ -1007,7 +1002,7 @@ module ActiveRecord #:nodoc:
 
         def construct_conditions_from_arguments(attribute_names, arguments)
           conditions = []
-          attribute_names.each_with_index { |name, idx| conditions << "#{table_name}.#{name} #{attribute_condition(arguments[idx])} " }
+          attribute_names.each_with_index { |name, idx| conditions << "#{table_name}.#{connection.quote_column_name(name)} #{attribute_condition(arguments[idx])} " }
           [ conditions.join(" AND "), *arguments[0...attribute_names.length] ]
         end
         
@@ -1050,12 +1045,12 @@ module ActiveRecord #:nodoc:
         def define_attr_method(name, value=nil, &block)
           sing = class << self; self; end
           sing.send :alias_method, "original_#{name}", name
-          if value
+          if block_given?
+            sing.send :define_method, name, &block
+          else
             # use eval instead of a block to work around a memory leak in dev
             # mode in fcgi
             sing.class_eval "def #{name}; #{value.to_s.inspect}; end"
-          else
-            sing.send :define_method, name, &block
           end
         end
 
@@ -1171,7 +1166,7 @@ module ActiveRecord #:nodoc:
         end
 
         def validate_find_options(options)
-          options.assert_valid_keys [:conditions, :include, :joins, :limit, :offset, :order, :select, :readonly]
+          options.assert_valid_keys [:conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group]
         end
 
         def encode_quoted_value(value)
@@ -1244,7 +1239,11 @@ module ActiveRecord #:nodoc:
         freeze
       end
 
-      # Returns a clone of the record that hasn't been assigned an id yet and is treated as a new record.
+      # Returns a clone of the record that hasn't been assigned an id yet and
+      # is treated as a new record.  Note that this is a "shallow" clone:
+      # it copies the object's attributes only, not its associations.
+      # The extent of a "deep" clone is application-specific and is therefore
+      # left to the application to implement according to its need.
       def clone
         attrs = self.attributes_before_type_cast
         attrs.delete(self.class.primary_key)
@@ -1305,6 +1304,7 @@ module ActiveRecord #:nodoc:
 
       # Reloads the attributes of this object from the database.
       def reload
+        clear_aggregation_cache
         clear_association_cache
         @attributes.update(self.class.find(self.id).instance_variable_get('@attributes'))
         self
@@ -1443,6 +1443,10 @@ module ActiveRecord #:nodoc:
 
       # Creates a new record with values matching those of the instance attributes.
       def create
+        if self.id.nil? and connection.prefetch_primary_key?(self.class.table_name)
+          self.id = connection.next_sequence_value(self.class.sequence_name)
+        end
+
         self.id = connection.insert(
           "INSERT INTO #{self.class.table_name} " +
           "(#{quoted_column_names.join(', ')}) " +
@@ -1542,7 +1546,16 @@ module ActiveRecord #:nodoc:
           self.class.read_methods << attr_name
         end
 
-        self.class.class_eval("def #{symbol}; #{access_code}; end")
+        begin
+          self.class.class_eval("def #{symbol}; #{access_code}; end")
+        rescue SyntaxError => err
+          self.class.read_methods.delete(attr_name)
+          if logger
+            logger.warn "Exception occured during reader method compilation."
+            logger.warn "Maybe #{attr_name} is not a valid Ruby identifier?"
+            logger.warn "#{err.message}"
+          end
+        end
       end
 
       # Returns true if the attribute is of a text column and marked for serialization.