activerecord 1.9.1 → 1.10.0

data/lib/active_record/associations/association_proxy.rb

@@ -25,13 +25,21 @@ module ActiveRecord
       end
 
       def respond_to?(symbol, include_priv = false)
-        load_target
-        proxy_respond_to?(symbol, include_priv) || @target.respond_to?(symbol, include_priv)
+        proxy_respond_to?(symbol, include_priv) || (load_target && @target.respond_to?(symbol, include_priv))
       end
 
       def loaded?
         @loaded
       end
+      
+      def target
+        @target
+      end
+      
+      def target=(t)
+        @target = t
+        @loaded = true
+      end
 
       protected
         def dependent?

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,7 +1,6 @@
 module ActiveRecord
   module Associations
     class BelongsToAssociation < AssociationProxy #:nodoc:
-
       def reset
         @target = nil
         @loaded = false

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -7,7 +7,7 @@ module ActiveRecord
         @association_foreign_key = options[:association_foreign_key] || Inflector.underscore(Inflector.demodulize(association_class_name)) + "_id"
         @association_table_name = options[:table_name] || @association_class.table_name
         @join_table = options[:join_table]
-        @order = options[:order] || "t.#{@association_class.primary_key}"
+        @order = options[:order]
 
         construct_sql
       end
@@ -51,7 +51,7 @@ module ActiveRecord
 
         # If no block is given, raise RecordNotFound.
         if ids.empty?
-          raise RecordNotFound, "Couldn't find #{@association_class.name} without an ID#{conditions}"
+          raise RecordNotFound, "Couldn't find #{@association_class.name} without an ID"
 
         # If using a custom finder_sql, scan the entire collection.
         elsif @options[:finder_sql]
@@ -66,7 +66,7 @@ module ActiveRecord
         # Otherwise, construct a query.
         else
           ids_list = ids.map { |id| @owner.send(:quote, id) }.join(',')
-          records = find_target(@finder_sql.sub(/ORDER BY/, "AND j.#{@association_foreign_key} IN (#{ids_list}) ORDER BY"))
+          records = find_target(@finder_sql.sub(/(ORDER BY|$)/, "AND j.#{@association_foreign_key} IN (#{ids_list}) \\1"))
           if records.size == ids.size
             if ids.size == 1 and !expects_array
               records.first
@@ -146,12 +146,18 @@ module ActiveRecord
 
         def construct_sql
           interpolate_sql_options!(@options, :finder_sql, :delete_sql)
-          @finder_sql = @options[:finder_sql] ||
-                "SELECT t.*, j.* FROM #{@join_table} j, #{@association_table_name} t " +
-                "WHERE t.#{@association_class.primary_key} = j.#{@association_foreign_key} AND " +
-                "j.#{@association_class_primary_key_name} = #{@owner.quoted_id} " +
-                (@options[:conditions] ? " AND " + interpolate_sql(@options[:conditions]) : "") + " " +
-                "ORDER BY #{@order}"
+          
+          if @options[:finder_sql]
+            @finder_sql = @options[:finder_sql]
+          else
+            @finder_sql = 
+              "SELECT t.*, j.* FROM #{@join_table} j, #{@association_table_name} t " +
+              "WHERE t.#{@association_class.primary_key} = j.#{@association_foreign_key} AND " +
+              "j.#{@association_class_primary_key_name} = #{@owner.quoted_id} "
+            
+            @finder_sql << " AND #{interpolate_sql(@options[:conditions])}" if @options[:conditions]
+            @finder_sql << " ORDER BY #{@order}" if @order
+          end
         end
     end
   end

data/lib/active_record/associations/has_many_association.rb

@@ -20,6 +20,7 @@ module ActiveRecord
         end
       end
 
+      # DEPRECATED.
       def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
         if @options[:finder_sql]
           records = @association_class.find_by_sql(@finder_sql)
@@ -31,6 +32,11 @@ module ActiveRecord
         end
       end
 
+      # DEPRECATED. Find the first associated record.  All arguments are optional.
+      def find_first(conditions = nil, orderings = nil)
+        find_all(conditions, orderings, 1).first
+      end
+
       # Count the number of associated records. All arguments are optional.
       def count(runtime_conditions = nil)
         if @options[:counter_sql]
@@ -43,24 +49,15 @@ module ActiveRecord
           @association_class.count(sql)
         end
       end
-      
-      # Find the first associated record.  All arguments are optional.
-      def find_first(conditions = nil, orderings = nil)
-        find_all(conditions, orderings, 1).first
-      end
 
       def find(*args)
-        # Return an Array if multiple ids are given.
-        expects_array = args.first.kind_of?(Array)
-
-        ids = args.flatten.compact.uniq
-
-        # If no ids given, raise RecordNotFound.
-        if ids.empty?
-          raise RecordNotFound, "Couldn't find #{@association_class.name} without an ID"
+        options = Base.send(:extract_options_from_args!, args)
 
         # If using a custom finder_sql, scan the entire collection.
-        elsif @options[:finder_sql]
+        if @options[:finder_sql]
+          expects_array = args.first.kind_of?(Array)
+          ids = args.flatten.compact.uniq
+
           if ids.size == 1
             id = ids.first
             record = load_target.detect { |record| id == record.id }
@@ -68,11 +65,10 @@ module ActiveRecord
           else
             load_target.select { |record| ids.include?(record.id) }
           end
-
-        # Otherwise, delegate to association class with conditions.
         else
-          args << { :conditions => "#{@association_class_primary_key_name} = #{@owner.quoted_id} #{@conditions ? " AND " + @conditions : ""}" }
-          @association_class.find(*args)
+          options[:conditions] = @finder_sql + (options[:conditions] ? " AND #{options[:conditions]}" : "")
+          options[:order] = options[:order] ? "#{options[:order]}, #{@options[:order]}" : @options[:order]
+          @association_class.find(args.size == 1 ? args.first : args, options)
         end
       end
 
@@ -113,11 +109,15 @@ module ActiveRecord
         end
 
         def delete_records(records)
-          ids = quoted_record_ids(records)
-          @association_class.update_all(
-            "#{@association_class_primary_key_name} = NULL", 
-            "#{@association_class_primary_key_name} = #{@owner.quoted_id} AND #{@association_class.primary_key} IN (#{ids})"
-          )
+          if @options[:dependent]
+            records.each { |r| r.destroy }
+          else
+            ids = quoted_record_ids(records)
+            @association_class.update_all(
+              "#{@association_class_primary_key_name} = NULL", 
+              "#{@association_class_primary_key_name} = #{@owner.quoted_id} AND #{@association_class.primary_key} IN (#{ids})"
+            )
+          end
         end
 
         def target_obsolete?
@@ -128,7 +128,7 @@ module ActiveRecord
           if @options[:finder_sql]
             @finder_sql = interpolate_sql(@options[:finder_sql])
           else
-            @finder_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}"
+            @finder_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
             @finder_sql << " AND #{interpolate_sql(@conditions)}" if @conditions
           end
 
@@ -138,7 +138,7 @@ module ActiveRecord
             @options[:counter_sql] = @options[:finder_sql].gsub(/SELECT (.*) FROM/i, "SELECT COUNT(*) FROM")
             @counter_sql = interpolate_sql(@options[:counter_sql])
           else
-            @counter_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}"
+            @counter_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
             @counter_sql << " AND #{interpolate_sql(@conditions)}" if @conditions
           end
         end

data/lib/active_record/associations/has_one_association.rb

@@ -38,7 +38,7 @@ module ActiveRecord
       
       private
         def find_target
-          @association_class.find_first(@finder_sql, @options[:order])
+          @association_class.find(:first, :conditions => @finder_sql, :order => @options[:order])
         end
 
         def target_obsolete?
@@ -46,7 +46,7 @@ module ActiveRecord
         end
 
         def construct_sql
-          @finder_sql = "#{@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}#{@options[:conditions] ? " AND " + @options[:conditions] : ""}"
         end
     end
   end

data/lib/active_record/base.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'active_record/deprecated_finders'
 
 module ActiveRecord #:nodoc:
   class ActiveRecordError < StandardError #:nodoc:
@@ -54,7 +55,7 @@ module ActiveRecord #:nodoc:
   # Active Records accepts constructor parameters either in a hash or as a block. The hash method is especially useful when
   # you're receiving the data from somewhere else, like a HTTP request. It works like this:
   # 
-  #   user = User.new("name" => "David", "occupation" => "Code Artist")
+  #   user = User.new(:name => "David", :occupation => "Code Artist")
   #   user.name # => "David"
   # 
   # You can also use block initialization:
@@ -95,7 +96,7 @@ module ActiveRecord #:nodoc:
   # question mark is supposed to represent. In those cases, you can resort to named bind variables instead. That's done by replacing 
   # the question marks with symbols and supplying a hash with values for the matching symbol keys:
   #
-  #   Company.find_first([ 
+  #   Company.find(:first, [ 
   #     "id = :id AND name = :name AND division = :division AND created_at > :accounting_date", 
   #     { :id => 3, :name => "37signals", :division => "First", :accounting_date => '2005-01-01' }
   #   ])
@@ -111,14 +112,17 @@ module ActiveRecord #:nodoc:
   #     # Uses an integer of seconds to hold the length of the song
   #     
   #     def length=(minutes)
-  #       write_attribute("length", minutes * 60)
+  #       write_attribute(:length, minutes * 60)
   #     end
   #     
   #     def length
-  #       read_attribute("length") / 60
+  #       read_attribute(:length) / 60
   #     end
   #   end
   # 
+  # You can alternatively use self[:attribute]=(value) and self[:attribute] instead of write_attribute(:attribute, vaule) and
+  # read_attribute(:attribute) as a shorter form.
+  #
   # == Accessing attributes before they have been type casted
   #
   # Some times you want to be able to read the raw attribute data without having the column-determined type cast run its course first.
@@ -133,16 +137,16 @@ module ActiveRecord #:nodoc:
   #
   # Dynamic attribute-based finders are a cleaner way of getting objects by simple queries without turning to SQL. They work by
   # appending the name of an attribute to <tt>find_by_</tt>, so you get finders like <tt>Person.find_by_user_name, Payment.find_by_transaction_id</tt>.
-  # So instead of writing <tt>Person.find_first(["user_name = ?", user_name])</tt>, you just do <tt>Person.find_by_user_name(user_name)</tt>.
+  # So instead of writing <tt>Person.find(:first, ["user_name = ?", user_name])</tt>, you just do <tt>Person.find_by_user_name(user_name)</tt>.
   # 
   # It's also possible to use multiple attributes in the same find by separating them with "_and_", so you get finders like
   # <tt>Person.find_by_user_name_and_password</tt> or even <tt>Payment.find_by_purchaser_and_state_and_country</tt>. So instead of writing
-  # <tt>Person.find_first(["user_name = ? AND password = ?", user_name, password])</tt>, you just do 
+  # <tt>Person.find(:first, ["user_name = ? AND password = ?", user_name, password])</tt>, you just do 
   # <tt>Person.find_by_user_name_and_password(user_name, password)</tt>.
   # 
-  # It's even possible to use all the additional parameters to find_first and find_all. For example, the full interface for Payment.find_all_by_amount
-  # is actually Payment.find_all_by_amount(amount, orderings = nil, limit = nil, joins = nil). And the full interface to Person.find_by_user_name is
-  # actually Person.find_by_user_name(user_name, orderings = nil)
+  # It's even possible to use all the additional parameters to find. For example, the full interface for Payment.find_all_by_amount
+  # is actually Payment.find_all_by_amount(amount, options). And the full interface to Person.find_by_user_name is
+  # actually Person.find_by_user_name(user_name, options). So you could call <tt>Payment.find_all_by_amount(50, :order => "created_on")</tt>.
   #
   # == Saving arrays, hashes, and other non-mappable objects in text columns
   # 
@@ -153,7 +157,7 @@ module ActiveRecord #:nodoc:
   #     serialize :preferences
   #   end
   # 
-  #   user = User.create("preferences" => { "background" => "black", "display" => large })
+  #   user = User.create(:preferences) => { "background" => "black", "display" => large })
   #   User.find(user.id).preferences # => { "background" => "black", "display" => large }
   # 
   # You can also specify an class option as the second parameter that'll raise an exception if a serialized object is retrieved as a 
@@ -163,7 +167,7 @@ module ActiveRecord #:nodoc:
   #     serialize :preferences, Hash
   #   end
   # 
-  #   user = User.create("preferences" => %w( one two three ))
+  #   user = User.create(:preferences => %w( one two three ))
   #   User.find(user.id).preferences    # raises SerializationTypeMismatch
   # 
   # == Single table inheritance
@@ -176,8 +180,8 @@ module ActiveRecord #:nodoc:
   #   class Client < Company; end
   #   class PriorityClient < Client; end
   #
-  # When you do Firm.create("name" => "37signals"), this record will be saved in the companies table with type = "Firm". You can then
-  # fetch this row again using Company.find_first "name = '37signals'" and it will return a Firm object.
+  # When you do Firm.create(:name => "37signals"), this record will be saved in the companies table with type = "Firm". You can then
+  # fetch this row again using Company.find(:first, "name = '37signals'") and it will return a Firm object.
   #
   # If you don't have a type column defined in your table, single-table inheritance won't be triggered. In that case, it'll work just
   # like normal subclasses with no special magic for differentiating between them or reloading the right type with find.
@@ -285,93 +289,76 @@ module ActiveRecord #:nodoc:
     @@default_timezone = :local
 
     class << self # Class methods
-      # Returns objects for the records responding to either a specific id (1), a list of ids (1, 5, 6) or an array of ids. 
-      # If only one ID is specified, that object is returned directly. If more than one ID is specified, an array is returned.
-      # Examples:
+      # Find operates with three different retreval approaches:
+      #
+      # * Find by id: This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+      #   If no record can be found for all of the listed ids, then RecordNotFound will be raised.
+      # * Find first: This will return the first record matched by the options used. These options can either be specific
+      #   conditions or merely an order. If no record can matched, nil is returned.
+      # * Find all: This will return all the records matched by the options used. If no records are found, an empty array is returned.
+      #
+      # All approaches accepts an option hash as their last parameter. The options are:
+      #
+      # * <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>: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).
+      # * <tt>:include</tt>: Names associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
+      #   to already defined associations. See eager loading under Associations.
+      #
+      # Examples for find by id:
       #   Person.find(1)       # returns the object for ID = 1
       #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
       #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
       #   Person.find([1])     # returns an array for objects the object with ID = 1
+      #   Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
       #
-      # The last argument may be a Hash of find options.  Currently, +conditions+ is the only option, behaving the same as with +find_all+.
-      #   Person.find(1, :conditions => "associate_id = 5"
-      #   Person.find(1, 2, 6, :conditions => "status = 'active'"
-      #   Person.find([7, 17], :conditions => ["sanitize_me = ?", "bare'quote"]
-      #   Person.find(25, :conditions => ["name = :name AND age = :age", { :name => "Mary", :age => 22 }]
+      # Examples for find first:
+      #   Person.find(:first) # returns the first object fetched by SELECT * FROM people
+      #   Person.find(:first, :conditions => [ "user_name = ?", user_name])
+      #   Person.find(:first, :order => "created_on DESC", :offset => 5)
       #
-      # +RecordNotFound+ is raised if no record can be found.
+      # Examples for find all:
+      #   Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
+      #   Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
+      #   Person.find(:all, :offset => 10, :limit => 10)
+      #   Person.find(:all, :include => [ :account, :friends ])
       def find(*args)
-        # Return an Array if ids are passed in an Array.
-        expects_array = args.first.kind_of?(Array)
-
-        # Extract options hash from argument list.
         options = extract_options_from_args!(args)
-        conditions = " AND #{sanitize_sql(options[:conditions])}" if options[:conditions]
-
-        ids = args.flatten.compact.uniq
-        case ids.size
-
-          # Raise if no ids passed.
-          when 0
-            raise RecordNotFound, "Couldn't find #{name} without an ID#{conditions}"
-
-          # Find a single id.
-          when 1
-            unless result = find_first("#{primary_key} = #{sanitize(ids.first)}#{conditions}")
-              raise RecordNotFound, "Couldn't find #{name} with ID=#{ids.first}#{conditions}"
-            end
-
-            # Box result if expecting array.
-            expects_array ? [result] : result
 
-          # Find multiple ids.
+        case args.first
+          when :first
+            find(:all, options.merge({ :limit => 1 })).first
+          when :all
+            options[:include] ? find_with_associations(options) : find_by_sql(construct_finder_sql(options))
           else
-            ids_list = ids.map { |id| sanitize(id) }.join(',')
-            result   = find_all("#{primary_key} IN (#{ids_list})#{conditions}", primary_key)
-            if result.size == ids.size
-              result
-            else
-              raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
+            expects_array = args.first.kind_of?(Array)
+            conditions = " AND #{sanitize_sql(options[:conditions])}" if options[:conditions]
+
+            ids = args.flatten.compact.uniq
+            case ids.size
+              when 0
+                raise RecordNotFound, "Couldn't find #{name} without an ID#{conditions}"
+              when 1
+                if result = find(:first, options.merge({ :conditions => "#{table_name}.#{primary_key} = #{sanitize(ids.first)}#{conditions}" }))
+                  return expects_array ? [ result ] : result
+                else
+                  raise RecordNotFound, "Couldn't find #{name} with ID=#{ids.first}#{conditions}"
+                end
+              else
+                # Find multiple ids
+                ids_list = ids.map { |id| sanitize(id) }.join(',')
+                result   = find(:all, options.merge({ :conditions => "#{table_name}.#{primary_key} IN (#{ids_list})#{conditions}", :order => primary_key }))
+                if result.size == ids.size
+                  return result
+                else
+                  raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
+                end
             end
         end
       end
 
-      # Returns true if the given +id+ represents the primary key of a record in the database, false otherwise.
-      # Example:
-      #   Person.exists?(5)
-      def exists?(id)
-        !find_first("#{primary_key} = #{sanitize(id)}").nil? rescue false
-      end
-
-      # This method is deprecated in favor of find with the :conditions option.
-      # Works like find, but the record matching +id+ must also meet the +conditions+.
-      # +RecordNotFound+ is raised if no record can be found matching the +id+ or meeting the condition.
-      # Example:
-      #   Person.find_on_conditions 5, "first_name LIKE '%dav%' AND last_name = 'heinemeier'"
-      def find_on_conditions(ids, conditions)
-        find(ids, :conditions => conditions)
-      end
-
-      # Returns an array of all the objects that could be instantiated from the associated
-      # table in the database. The +conditions+ can be used to narrow the selection of objects (WHERE-part),
-      # such as by "color = 'red'", and arrangement of the selection can be done through +orderings+ (ORDER BY-part),
-      # such as by "last_name, first_name DESC". A maximum of returned objects and their offset can be specified in 
-      # +limit+ with either just a single integer as the limit or as an array with the first element as the limit, 
-      # the second as the offset. Examples:
-      #   Project.find_all "category = 'accounts'", "last_accessed DESC", 15
-      #   Project.find_all ["category = ?", category_name], "created ASC", [15, 20]
-      def find_all(conditions = nil, orderings = nil, limit = nil, joins = nil)
-        sql  = "SELECT * FROM #{table_name} " 
-        sql << "#{joins} " if joins
-        add_conditions!(sql, conditions)
-        sql << "ORDER BY #{orderings} " unless orderings.nil?
-
-        limit = sanitize_sql(limit) if limit.is_a? Array and limit.first.is_a? String
-        connection.add_limit!(sql, limit) if limit
-
-        find_by_sql(sql)
-      end
-  
       # Works like find_all, but requires a complete SQL string. Examples:
       #   Post.find_by_sql "SELECT p.*, c.author FROM posts p, comments c WHERE p.id = c.post_id"
       #   Post.find_by_sql ["SELECT * FROM posts WHERE author = ? AND created > ?", author_id, start_date]
@@ -379,15 +366,13 @@ module ActiveRecord #:nodoc:
         connection.select_all(sanitize_sql(sql), "#{name} Load").inject([]) { |objects, record| objects << instantiate(record) }
       end
       
-      # Returns the object for the first record responding to the conditions in +conditions+, 
-      # such as "group = 'master'". If more than one record is returned from the query, it's the first that'll
-      # be used to create the object. In such cases, it might be beneficial to also specify 
-      # +orderings+, like "income DESC, name", to control exactly which record is to be used. Example: 
-      #   Employee.find_first "income > 50000", "income DESC, name"
-      def find_first(conditions = nil, orderings = nil)
-        find_all(conditions, orderings, 1).first
+      # Returns true if the given +id+ represents the primary key of a record in the database, false otherwise.
+      # Example:
+      #   Person.exists?(5)
+      def exists?(id)
+        !find(:first, :conditions => ["#{primary_key} = ?", id]).nil? rescue false
       end
-    
+
       # Creates an object, instantly saves it as a record (if the validation permits it), and returns it. If the save
       # fail under validations, the unsaved object is still returned.
       def create(attributes = nil)
@@ -452,8 +437,10 @@ module ActiveRecord #:nodoc:
     
       # Returns the number of records that meets the +conditions+. Zero is returned if no records match. Example:
       #   Product.count "sales > 1"
-      def count(conditions = nil)
-        sql  = "SELECT COUNT(*) FROM #{table_name} "
+      def count(conditions = nil, joins = nil)
+        tbl_var_name = joins ? table_name[0,1].downcase : ""
+        sql  = "SELECT COUNT(*) FROM #{table_name} #{tbl_var_name} "
+        sql << ", #{joins} " if joins
         add_conditions!(sql, conditions)
         count_by_sql(sql)
       end
@@ -462,8 +449,14 @@ module ActiveRecord #:nodoc:
       #   Product.count "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
       def count_by_sql(sql)
         sql = sanitize_conditions(sql)
-        count = connection.select_one(sql, "#{name} Count").values.first
-        return count ? count.to_i : 0
+        rows = connection.select_one(sql, "#{name} Count")
+
+        if rows.nil?
+          return 0
+        else
+          count = rows.values.first
+          return count ? count.to_i : 0
+        end
       end
         
       # Increments the specified counter by one. So <tt>DiscussionBoard.increment_counter("post_count", 
@@ -625,6 +618,10 @@ module ActiveRecord #:nodoc:
       def columns_hash
         @columns_hash ||= columns.inject({}) { |hash, column| hash[column.name] = column; hash }
       end
+      
+      def column_names
+        @column_names ||= columns_hash.keys
+      end
 
       # Returns an array of columns objects where the primary id, all columns ending in "_id" or "_count", 
       # and columns used for single table inheritance has been removed.
@@ -647,7 +644,7 @@ module ActiveRecord #:nodoc:
       
       # Resets all the cached information about columns, which will cause they to be reloaded on the next request.
       def reset_column_information
-        @columns = @columns_hash = @content_columns = @dynamic_methods_hash = nil
+        @column_names = @columns = @columns_hash = @content_columns = @dynamic_methods_hash = nil
       end
 
       def reset_column_information_and_inheritable_attributes_for_all_subclasses#:nodoc:
@@ -685,16 +682,17 @@ module ActiveRecord #:nodoc:
       def benchmark(title)
         result = nil
         bm = Benchmark.measure { result = silence { yield } }
-        logger.info "#{title} (#{sprintf("%f", bm.real)})"
+        logger.info "#{title} (#{sprintf("%f", bm.real)})" if logger
         return result
       end
       
       # Silences the logger for the duration of the block.
       def silence
         result = nil
-        logger.level = Logger::ERROR
+        old_logger_level = logger.level if logger
+        logger.level = Logger::ERROR if logger
         result = yield
-        logger.level = Logger::DEBUG
+        logger.level = old_logger_level if logger
         return result
       end
 
@@ -737,6 +735,24 @@ module ActiveRecord #:nodoc:
           self.name =~ /::/ ? self.name.scan(/(.*)::/).first.first + "::" + type_name : type_name
         end
 
+        def construct_finder_sql(options)
+          sql  = "SELECT * FROM #{table_name} " 
+          sql << "#{options[:joins]} " if options[:joins]
+          add_conditions!(sql, options[:conditions])
+          sql << "ORDER BY #{options[:order]} " if options[:order]
+          add_limit!(sql, options)
+          
+          return sql
+        end
+
+        def add_limit!(sql, options)
+          if options[:limit] && options[:offset]
+            connection.add_limit_with_offset!(sql, options[:limit].to_i, options[:offset].to_i)
+          elsif options[:limit]
+            connection.add_limit_without_offset!(sql, options[:limit].to_i)
+          end
+        end
+
         # Adds a sanitized version of +conditions+ to the +sql+ string. Note that it's the passed +sql+ string is changed.
         def add_conditions!(sql, conditions)
           sql << "WHERE #{sanitize_sql(conditions)} " unless conditions.nil?
@@ -744,9 +760,11 @@ module ActiveRecord #:nodoc:
         end
         
         def type_condition
-          " (" + subclasses.inject("#{inheritance_column} = '#{Inflector.demodulize(name)}' ") do |condition, subclass| 
-            condition << "OR #{inheritance_column} = '#{Inflector.demodulize(subclass.name)}' "
-          end + ") "
+          type_condition = subclasses.inject("#{table_name}.#{inheritance_column} = '#{name.demodulize}' ") do |condition, subclass| 
+            condition << "OR #{table_name}.#{inheritance_column} = '#{subclass.name.demodulize}' "
+          end
+          
+          return " (#{type_condition}) "
         end
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.
@@ -760,18 +778,24 @@ module ActiveRecord #:nodoc:
         # find_first(["user_name = ?", user_name]) and find_first(["user_name = ? AND password = ?", user_name, password]) respectively. Also works
         # for find_all, but using find_all_by_amount(50) that are turned into find_all(["amount = ?", 50]).
         # 
-        # It's even possible to use all the additional parameters to find_first and find_all. For example, the full interface for find_all_by_amount
-        # is actually find_all_by_amount(amount, orderings = nil, limit = nil, joins = nil).
+        # It's even possible to use all the additional parameters to find. For example, the full interface for find_all_by_amount
+        # is actually find_all_by_amount(amount, options).
         def method_missing(method_id, *arguments)
           method_name = method_id.id2name
 
           if method_name =~ /find_(all_by|by)_([_a-z][_a-z\d]*)/
-            finder, attributes = ($1 == "all_by" ? :find_all : :find_first), $2.split("_and_")
+            finder, attributes = ($1 == "all_by" ? :all : :first), $2.split("_and_")
             attributes.each { |attr_name| super unless column_methods_hash[attr_name.intern] }
 
             attr_index = -1
             conditions = attributes.collect { |attr_name| attr_index += 1; "#{attr_name} #{arguments[attr_index].nil? ? "IS" : "="} ? " }.join(" AND ")
-            send(finder, [conditions, *arguments[0...attributes.length]], *arguments[attributes.length..-1])
+            
+            if arguments[attributes.length].is_a?(Hash)
+              find(finder, { :conditions => [conditions, *arguments[0...attributes.length]]}.merge(arguments[attributes.length]))
+            else
+              # deprecated API
+              send("find_#{finder}", [conditions, *arguments[0...attributes.length]], *arguments[attributes.length..-1])
+            end
           else
             super
           end
@@ -1085,7 +1109,7 @@ module ActiveRecord #:nodoc:
       # Delegates to id in order to allow two records of the same type and id to work with something like:
       #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
       def hash
-        id
+        id.hash
       end
 
       # For checking respond_to? without searching the attributes (which is faster).