activerecord 1.11.1 → 1.12.1

data/lib/active_record/associations/association_collection.rb

@@ -33,6 +33,12 @@ module ActiveRecord
 
       alias_method :push, :<<
       alias_method :concat, :<<
+                      
+      # Remove all records from this association
+      def delete_all
+        delete(@target)
+        @target = []
+      end
 
       # Remove +records+ from this association.  Does not destroy +records+.
       def delete(*records)
@@ -50,6 +56,17 @@ module ActiveRecord
           end
         end
       end
+
+      # Removes all records from this association.  Returns +self+ so method calls may be chained.
+      def clear
+        return self if empty? # forces load_target if hasn't happened already
+        if @options[:exclusively_dependent]
+          destroy_all
+        else          
+          delete_all
+        end
+        self
+      end
       
       def destroy_all
         @owner.transaction do
@@ -107,6 +124,14 @@ module ActiveRecord
       end
 
       private
+        def method_missing(method, *args, &block)
+          if @target.respond_to?(method) or (not @association_class.respond_to?(method) and Class.respond_to?(method))
+            super
+          else
+            @association_class.constrain(:conditions => @finder_sql, :joins => @join_sql) { @association_class.send(method, *args, &block) }
+          end
+        end
+              
         def raise_on_type_mismatch(record)
           raise ActiveRecord::AssociationTypeMismatch, "#{@association_class} expected, got #{record.class}" unless record.is_a?(@association_class)
         end

data/lib/active_record/associations/association_proxy.rb

@@ -8,7 +8,7 @@ module ActiveRecord
         @owner = owner
         @options = options
         @association_name = association_name
-        @association_class = eval(association_class_name)
+        @association_class = eval(association_class_name, nil, __FILE__, __LINE__)
         @association_class_primary_key_name = association_class_primary_key_name
 
         reset
@@ -19,11 +19,6 @@ module ActiveRecord
         load_target
       end
 
-      def method_missing(symbol, *args, &block)
-        load_target
-        @target.send(symbol, *args, &block)
-      end
-
       def respond_to?(symbol, include_priv = false)
         proxy_respond_to?(symbol, include_priv) || (load_target && @target.respond_to?(symbol, include_priv))
       end
@@ -44,7 +39,7 @@ module ActiveRecord
         @target = t
         @loaded = true
       end
-
+      
       protected
         def dependent?
           @options[:dependent] || false
@@ -69,8 +64,14 @@ module ActiveRecord
         def extract_options_from_args!(args)
           @owner.send(:extract_options_from_args!, args)
         end
-
+        
       private
+        
+        def method_missing(method, *args, &block)
+          load_target
+          @target.send(method, *args, &block)
+        end
+
         def load_target
           if !@owner.new_record? || foreign_key_present
             begin

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,14 +1,20 @@
 module ActiveRecord
   module Associations
     class BelongsToAssociation < AssociationProxy #:nodoc:
+      
+      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
+        super        
+        construct_sql        
+      end
+      
       def reset
         @target = nil
         @loaded = false
       end
 
       def create(attributes = {})
-        record = build(attributes)
-        record.save
+        record = @association_class.create(attributes)
+        replace(record, true)
         record
       end
 
@@ -24,13 +30,21 @@ module ActiveRecord
         else
           raise_on_type_mismatch(obj) unless obj.nil?
 
-          @target = obj
+          @target = (AssociationProxy === obj ? obj.target : obj)
           @owner[@association_class_primary_key_name] = obj.id unless obj.new_record?
+          @updated = true
         end
         @loaded = true
 
         return (@target.nil? ? nil : self)
       end
+      
+      def updated?
+        @updated
+      end
+      
+      protected
+
 
       private
         def find_target
@@ -48,9 +62,9 @@ module ActiveRecord
         def target_obsolete?
           @owner[@association_class_primary_key_name] != @target.id
         end
-
+        
         def construct_sql
-          # no sql to construct
+          @finder_sql = "#{@association_class.table_name}.#{@association_class.primary_key} = #{@owner.id}"
         end
     end
   end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -4,7 +4,7 @@ module ActiveRecord
       def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
         super
 
-        @association_foreign_key = options[:association_foreign_key] || Inflector.underscore(Inflector.demodulize(association_class_name)) + "_id"
+        @association_foreign_key = options[:association_foreign_key] || association_class_name.foreign_key
         @association_table_name = options[:table_name] || @association_class.table_name
         @join_table = options[:join_table]
         @order = options[:order]
@@ -19,65 +19,44 @@ module ActiveRecord
         record
       end
 
-      # Removes all records from this association.  Returns +self+ so method calls may be chained.
-      def clear
-        return self if size == 0 # forces load_target if hasn't happened already
-
-        if sql = @options[:delete_sql]
-          each { |record| @owner.connection.execute(sql) }
-        elsif @options[:conditions] 
-          sql = 
-            "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = #{@owner.quoted_id} " +
-            "AND #{@association_foreign_key} IN (#{collect { |record| record.id }.join(", ")})"
-          @owner.connection.execute(sql)
-        else
-          sql = "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = #{@owner.quoted_id}"
-          @owner.connection.execute(sql)
-        end
-
-        @target = []
-        self
-      end
-
       def find_first
         load_target.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 block is 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
+            id = ids.first.to_i
             record = load_target.detect { |record| id == record.id }
-            expects_array? ? [record] : record
+            expects_array ? [record] : record
           else
             load_target.select { |record| ids.include?(record.id) }
           end
-
-        # 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}) \\1"))
-          if records.size == ids.size
-            if ids.size == 1 and !expects_array
-              records.first
-            else
-              records
-            end
-          else
-            raise RecordNotFound, "Couldn't find #{@association_class.name} with ID in (#{ids_list})"
+          conditions = "#{@finder_sql}"
+          if sanitized_conditions = sanitize_sql(options[:conditions])
+            conditions << " AND (#{sanitized_conditions})"
+          end
+          options[:conditions] = conditions
+          options[:joins] = @join_sql
+
+          if options[:order] && @options[:order]
+            options[:order] = "#{options[:order]}, #{@options[:order]}"
+          elsif @options[:order]
+            options[:order] = @options[:order]
           end
+
+          # Pass through args exactly as we received them.
+          args << options
+          @association_class.find(*args)
         end
-      end
+      end      
 
       def push_with_attributes(record, join_attributes = {})
         raise_on_type_mismatch(record)
@@ -96,11 +75,16 @@ module ActiveRecord
       end
       
       protected
-        def find_target(sql = @finder_sql)
-          records = @association_class.find_by_sql(sql)
+        def find_target
+          if @options[:finder_sql]
+            records = @association_class.find_by_sql(@finder_sql)
+          else
+            records = find(:all)
+          end
+          
           @options[:uniq] ? uniq(records) : records
         end
-
+        
         def count_records
           load_target.size
         end
@@ -122,15 +106,17 @@ module ActiveRecord
                 when @association_foreign_key
                   attributes[column.name] = record.quoted_id
                 else
-                  value = record[column.name]
-                  attributes[column.name] = value unless value.nil?
+                  if record.attributes.has_key?(column.name)
+                    value = @owner.send(:quote, record[column.name], column)
+                    attributes[column.name] = value unless value.nil?
+                  end
               end
               attributes
             end
 
             sql =
               "INSERT INTO #{@join_table} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
-              "VALUES (#{attributes.values.collect { |value| @owner.send(:quote, value) }.join(', ')})"
+              "VALUES (#{attributes.values.join(', ')})"
 
             @owner.connection.execute(sql)
           end
@@ -150,28 +136,17 @@ module ActiveRecord
 
         def construct_sql
           interpolate_sql_options!(@options, :finder_sql)
-          
+
           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]
-
-            unless @association_class.descends_from_active_record?
-              type_condition = @association_class.send(:subclasses).inject("t.#{@association_class.inheritance_column} = '#{@association_class.name.demodulize}' ") do |condition, subclass| 
-                condition << "OR t.#{@association_class.inheritance_column} = '#{subclass.name.demodulize}' "
-              end
-
-              @finder_sql << " AND (#{type_condition})"
-            end
-	
-            @finder_sql << " ORDER BY #{@order}" if @order
+            @finder_sql = "#{@join_table}.#{@association_class_primary_key_name} = #{@owner.quoted_id} "
+            @finder_sql << " AND (#{interpolate_sql(@options[:conditions])})" if @options[:conditions]
           end
+          
+          @join_sql = "LEFT JOIN #{@join_table} ON #{@association_class.table_name}.#{@association_class.primary_key} = #{@join_table}.#{@association_foreign_key}"
         end
+        
     end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -26,7 +26,7 @@ module ActiveRecord
           records = @association_class.find_by_sql(@finder_sql)
         else
           sql = @finder_sql
-          sql += " AND #{sanitize_sql(runtime_conditions)}" if runtime_conditions
+          sql += " AND (#{sanitize_sql(runtime_conditions)})" if runtime_conditions
           orderings ||= @options[:order]
           records = @association_class.find_all(sql, orderings, limit, joins)
         end
@@ -45,7 +45,7 @@ module ActiveRecord
           @association_class.count_by_sql(@finder_sql)
         else
           sql = @finder_sql
-          sql += " AND #{sanitize_sql(runtime_conditions)}" if runtime_conditions
+          sql += " AND (#{sanitize_sql(runtime_conditions)})" if runtime_conditions
           @association_class.count(sql)
         end
       end
@@ -68,7 +68,7 @@ module ActiveRecord
         else
           conditions = "#{@finder_sql}"
           if sanitized_conditions = sanitize_sql(options[:conditions])
-            conditions << " AND #{sanitized_conditions}"
+            conditions << " AND (#{sanitized_conditions})"
           end
           options[:conditions] = conditions
 
@@ -83,15 +83,7 @@ module ActiveRecord
           @association_class.find(*args)
         end
       end
-
-      # Removes all records from this association.  Returns +self+ so
-      # method calls may be chained.
-      def clear
-        @association_class.update_all("#{@association_class_primary_key_name} = NULL", "#{@association_class_primary_key_name} = #{@owner.quoted_id}")
-        @target = []
-        self
-      end
-
+      
       protected
         def find_target
           find_all
@@ -145,7 +137,7 @@ module ActiveRecord
             @finder_sql = interpolate_sql(@options[:finder_sql])
           else
             @finder_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
-            @finder_sql << " AND #{interpolate_sql(@conditions)}" if @conditions
+            @finder_sql << " AND (#{interpolate_sql(@conditions)})" if @conditions
           end
 
           if @options[:counter_sql]
@@ -155,7 +147,7 @@ module ActiveRecord
             @counter_sql = interpolate_sql(@options[:counter_sql])
           else
             @counter_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}"
-            @counter_sql << " AND #{interpolate_sql(@conditions)}" if @conditions
+            @counter_sql << " AND (#{interpolate_sql(@conditions)})" if @conditions
           end
         end
     end

data/lib/active_record/associations/has_one_association.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       def replace(obj, dont_save = false)
         load_target
         unless @target.nil?
-          if dependent? && !dont_save     
+          if dependent? && !dont_save && @target != obj
             @target.destroy unless @target.new_record?
             @owner.clear_association_cache
           else
@@ -44,7 +44,7 @@ module ActiveRecord
           raise_on_type_mismatch(obj)
           
           obj[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
-          @target = obj
+          @target = (AssociationProxy === obj ? obj.target : obj)
         end
 
         @loaded = true
@@ -54,7 +54,7 @@ module ActiveRecord
           return (obj.nil? ? nil : self)
         end
       end
-      
+            
       private
         def find_target
           @association_class.find(:first, :conditions => @finder_sql, :order => @options[:order])
@@ -66,6 +66,8 @@ module ActiveRecord
 
         def construct_sql
           @finder_sql = "#{@association_class.table_name}.#{@association_class_primary_key_name} = #{@owner.quoted_id}#{@options[:conditions] ? " AND " + @options[:conditions] : ""}"
+          @finder_sql << " AND (#{sanitize_sql(@options[:conditions])})" if @options[:conditions]
+          @finder_sql
         end
     end
   end

data/lib/active_record/base.rb

@@ -28,7 +28,9 @@ module ActiveRecord #:nodoc:
   end
   class ConfigurationError < StandardError #:nodoc:
   end
-
+  class ReadOnlyRecord < StandardError #:nodoc:
+  end
+  
   class AttributeAssignmentError < ActiveRecordError #:nodoc:
     attr_reader :exception, :attribute
     def initialize(message, exception, attribute)
@@ -45,7 +47,7 @@ module ActiveRecord #:nodoc:
     end
   end
 
-  # Active Record objects doesn't specify their attributes directly, but rather infer them from the table definition with
+  # Active Record objects don't specify their attributes directly, but rather infer them from the table definition with
   # which they're linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change
   # is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain
   # database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.
@@ -54,7 +56,7 @@ module ActiveRecord #:nodoc:
   #
   # == Creation
   #
-  # Active Records accepts constructor parameters either in a hash or as a block. The hash method is especially useful when
+  # Active Records accept 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")
@@ -77,7 +79,7 @@ module ActiveRecord #:nodoc:
   #
   # Conditions can either be specified as a string or an array representing the WHERE-part of an SQL statement.
   # The array form is to be used when the condition input is tainted and requires sanitization. The string form can
-  # be used for statements that doesn't involve tainted data. Examples:
+  # be used for statements that don't involve tainted data. Examples:
   #
   #   User < ActiveRecord::Base
   #     def self.authenticate_unsafely(user_name, password)
@@ -125,14 +127,14 @@ module ActiveRecord #:nodoc:
   # 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
+  # == Accessing attributes before they have been typecasted
   #
-  # Some times you want to be able to read the raw attribute data without having the column-determined type cast run its course first.
+  # Sometimes you want to be able to read the raw attribute data without having the column-determined typecast run its course first.
   # That can be done by using the <attribute>_before_type_cast accessors that all attributes have. For example, if your Account model
   # has a balance attribute, you can call account.balance_before_type_cast or account.id_before_type_cast.
   #
   # This is especially useful in validation situations where the user might supply a string for an integer field and you want to display
-  # the original string back in an error message. Accessing the attribute normally would type cast the string to 0, which isn't what you
+  # the original string back in an error message. Accessing the attribute normally would typecast the string to 0, which isn't what you
   # want.
   #
   # == Dynamic attribute-based finders
@@ -155,7 +157,7 @@ module ActiveRecord #:nodoc:
   # == Saving arrays, hashes, and other non-mappable objects in text columns
   #
   # Active Record can serialize any object in text columns using YAML. To do so, you must specify this with a call to the class method +serialize+.
-  # This makes it possible to store arrays, hashes, and other non-mappeable objects without doing any additional work. Example:
+  # This makes it possible to store arrays, hashes, and other non-mappable objects without doing any additional work. Example:
   #
   #   class User < ActiveRecord::Base
   #     serialize :preferences
@@ -164,7 +166,7 @@ module ActiveRecord #:nodoc:
   #   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
+  # You can also specify a class option as the second parameter that'll raise an exception if a serialized object is retrieved as a
   # descendent of a class not in the hierarchy. Example:
   #
   #   class User < ActiveRecord::Base
@@ -208,7 +210,7 @@ module ActiveRecord #:nodoc:
   # * +ActiveRecordError+ -- generic error class and superclass of all other errors raised by Active Record
   # * +AdapterNotSpecified+ -- the configuration hash used in <tt>establish_connection</tt> didn't include a
   #   <tt>:adapter</tt> key.
-  # * +AdapterNotSpecified+ -- the <tt>:adapter</tt> key used in <tt>establish_connection</tt> specified an non-existent adapter
+  # * +AdapterNotFound+ -- the <tt>:adapter</tt> key used in <tt>establish_connection</tt> specified an non-existent adapter
   #   (or a bad spelling of an existing one).
   # * +AssociationTypeMismatch+ -- the object assigned to the association wasn't of the type specified in the association definition.
   # * +SerializationTypeMismatch+ -- the object serialized wasn't of the class specified as the second parameter.
@@ -222,12 +224,11 @@ module ActiveRecord #:nodoc:
   #   objects that should be inspected to determine which attributes triggered the errors.
   # * +AttributeAssignmentError+ -- an error occurred while doing a mass assignment through the +attributes=+ method.
   #   You can inspect the +attribute+ property of the exception object to determine which attribute triggered the error.
+  #
   # *Note*: The attributes listed are class-level attributes (accessible from both the class and instance level).
   # So it's possible to assign a logger to the class through Base.logger= which will then be used by all
   # instances in the current object space.
   class Base
-    include ClassInheritableAttributes
-
     # Accepts a logger conforming to the interface of Log4r or the default Ruby 1.8+ Logger class, which is then passed
     # 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
@@ -236,7 +237,11 @@ module ActiveRecord #:nodoc:
     # also be used to "borrow" the connection to do database work unrelated
     # to any of the specific Active Records.
     def self.connection
-      retrieve_connection
+      if allow_concurrency
+        retrieve_connection
+      else
+        @connection ||= retrieve_connection
+      end
     end
 
     # Returns the connection currently associated with the class. This can
@@ -251,6 +256,28 @@ module ActiveRecord #:nodoc:
       @@subclasses[self] << child
       super
     end
+    
+    # Allow all subclasses of AR::Base to be reloaded in dev mode, unless they
+    # explicitly decline the honor. USE WITH CAUTION. Only AR subclasses kept
+    # in the framework should use the flag, so #reset_subclasses and so forth
+    # leave it alone.
+    def self.reloadable? #:nodoc:
+      true
+    end
+
+    def self.reset_subclasses
+      nonreloadables = []
+      subclasses.each do |klass|
+        unless klass.reloadable?
+          nonreloadables << klass
+          next
+        end
+        klass.instance_variables.each { |var| klass.send(:remove_instance_variable, var) }
+        klass.instance_methods(false).each { |m| klass.send :undef_method, m }
+      end
+      @@subclasses = {}
+      nonreloadables.each { |klass| (@@subclasses[klass.superclass] ||= []) << klass }
+    end
 
     @@subclasses = {}
 
@@ -275,14 +302,14 @@ module ActiveRecord #:nodoc:
     cattr_accessor :table_name_suffix
     @@table_name_suffix = ""
 
-    # Indicate whether or not table names should be the pluralized versions of the corresponding class names.
-    # If true, this the default table name for a +Product+ class will be +products+. If false, it would just be +product+.
+    # Indicates whether or not table names should be the pluralized versions of the corresponding class names.
+    # If true, the default table name for a +Product+ class will be +products+. If false, it would just be +product+.
     # See table_name for the full rules on table/class naming. This is true, by default.
     cattr_accessor :pluralize_table_names
     @@pluralize_table_names = true
 
     # Determines whether or not to use ANSI codes to colorize the logging statements committed by the connection adapter. These colors
-    # makes it much easier to overview things during debugging (when used through a reader like +tail+ and on a black background), but
+    # make it much easier to overview things during debugging (when used through a reader like +tail+ and on a black background), but
     # may complicate matters if you use software like syslog. This is true, by default.
     cattr_accessor :colorize_logging
     @@colorize_logging = true
@@ -294,11 +321,27 @@ module ActiveRecord #:nodoc:
     
     # Determines whether or not to use a connection for each thread, or a single shared connection for all threads.
     # Defaults to true; Railties' WEBrick server sets this to false.
-    cattr_accessor :threaded_connections
-    @@threaded_connections = true
+    cattr_accessor :allow_concurrency
+    @@allow_concurrency = true
+    
+    # Determines whether to speed up access by generating optimized reader
+    # methods to avoid expensive calls to method_missing when accessing
+    # attributes by name. You might want to set this to false in development
+    # mode, because the methods would be regenerated on each request.
+    cattr_accessor :generate_read_methods
+    @@generate_read_methods = true
+    
+    # Specifies the format to use when dumping the database schema with Rails'
+    # Rakefile.  If :sql, the schema is dumped as (potentially database-
+    # specific) SQL statements.  If :ruby, the schema is dumped as an 
+    # ActiveRecord::Schema file which can be loaded into any database that
+    # supports migrations.  Use :ruby if you want to have different database
+    # adapters for, e.g., your development and test environments.
+    cattr_accessor :schema_format 
+    @@schema_format = :sql
 
     class << self # Class methods
-      # Find operates with three different retreval approaches:
+      # Find operates with three different retrieval 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.
@@ -306,15 +349,20 @@ module ActiveRecord #:nodoc:
       #   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:
+      # All approaches accept 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).
+      #   The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+      #   Use <tt>find_by_sql</tt> to circumvent this limitation.
       # * <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.
+      # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
+      #   include the joined columns.
+      # * <tt>:readonly</tt>: Mark the returned records read-only so they cannot be saved or updated.
       #
       # Examples for find by id:
       #   Person.find(1)       # returns the object for ID = 1
@@ -336,15 +384,21 @@ module ActiveRecord #:nodoc:
       def find(*args)
         options = extract_options_from_args!(args)
 
+        # :joins implies :readonly => true
+        options[:readonly] = true if options[:joins]
+
         case args.first
           when :first
             find(:all, options.merge(options[:include] ? { } : { :limit => 1 })).first
           when :all
-            options[:include] ? find_with_associations(options) : find_by_sql(construct_finder_sql(options))
+            records = options[:include] ? find_with_associations(options) : find_by_sql(construct_finder_sql(options))
+            records.each { |record| record.readonly! } if options[:readonly]
+            records
           else
             return args.first if args.first.kind_of?(Array) && args.first.empty?
             expects_array = args.first.kind_of?(Array)
-            conditions = " AND #{sanitize_sql(options[:conditions])}" if options[:conditions]
+            
+            conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
 
             ids = args.flatten.compact.uniq
             case ids.size
@@ -384,7 +438,7 @@ module ActiveRecord #:nodoc:
       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.
+      # fails under validations, the unsaved object is still returned.
       def create(attributes = nil)
         if attributes.is_a?(Array)
           attributes.collect { |attr| create(attr) }
@@ -396,7 +450,7 @@ module ActiveRecord #:nodoc:
       end
 
       # Finds the record from the passed +id+, instantly saves it with the passed +attributes+ (if the validation permits it),
-      # and returns it. If the save fail under validations, the unsaved object is still returned.
+      # and returns it. If the save fails under validations, the unsaved object is still returned.
       def update(id, attributes)
         if id.is_a?(Array)
           idx = -1
@@ -420,7 +474,7 @@ module ActiveRecord #:nodoc:
         id.is_a?(Array) ? id.each { |id| destroy(id) } : find(id).destroy
       end
 
-      # Updates all records with the SET-part of an SQL update statement in +updates+ and returns an integer with the number of rows updates.
+      # Updates all records with the SET-part of an SQL update statement in +updates+ and returns an integer with the number of rows updated.
       # A subset of the records can be selected by specifying +conditions+. Example:
       #   Billing.update_all "category = 'authorized', approved = 1", "author = 'David'"
       def update_all(updates, conditions = nil)
@@ -429,14 +483,14 @@ module ActiveRecord #:nodoc:
         connection.update(sql, "#{name} Update")
       end
 
-      # Destroys the objects for all the records that matches the +condition+ by instantiating each object and calling
+      # Destroys the objects for all the records that match the +condition+ by instantiating each object and calling
       # the destroy method. Example:
       #   Person.destroy_all "last_login < '2004-04-04'"
       def destroy_all(conditions = nil)
         find(:all, :conditions => conditions).each { |object| object.destroy }
       end
 
-      # Deletes all the records that matches the +condition+ without instantiating the objects first (and hence not
+      # 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')"
       def delete_all(conditions = nil)
@@ -445,7 +499,7 @@ module ActiveRecord #:nodoc:
         connection.delete(sql, "#{name} Delete all")
       end
 
-      # Returns the number of records that meets the +conditions+. Zero is returned if no records match. Example:
+      # Returns the number of records that meet the +conditions+. Zero is returned if no records match. Example:
       #   Product.count "sales > 1"
       def count(conditions = nil, joins = nil)
         sql  = "SELECT COUNT(*) FROM #{table_name} "
@@ -455,21 +509,15 @@ module ActiveRecord #:nodoc:
       end
 
       # Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part.
-      #   Product.count "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
+      #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
       def count_by_sql(sql)
         sql = sanitize_conditions(sql)
-        rows = connection.select_one(sql, "#{name} Count")
-
-        if !rows.nil? and count = rows.values.first
-          count.to_i
-        else
-          0
-        end
+        connection.select_value(sql, "#{name} Count").to_i
       end
 
       # Increments the specified counter by one. So <tt>DiscussionBoard.increment_counter("post_count",
       # discussion_board_id)</tt> would increment the "post_count" counter on the board responding to discussion_board_id.
-      # This is used for caching aggregate values, so that they doesn't need to be computed every time. Especially important
+      # This is used for caching aggregate values, so that they don't need to be computed every time. Especially important
       # for looping over a collection where each element require a number of aggregate values. Like the DiscussionBoard
       # that needs to list both the number of posts and comments.
       def increment_counter(counter_name, id)
@@ -483,7 +531,7 @@ module ActiveRecord #:nodoc:
 
       # Attributes named in this macro are protected from mass-assignment, such as <tt>new(attributes)</tt> and
       # <tt>attributes=(attributes)</tt>. Their assignment will simply be ignored. Instead, you can use the direct writer
-      # methods to do assignment. This is meant to protect sensitive attributes to be overwritten by URL/form hackers. Example:
+      # methods to do assignment. This is meant to protect sensitive attributes from being overwritten by URL/form hackers. Example:
       #
       #   class Customer < ActiveRecord::Base
       #     attr_protected :credit_rating
@@ -497,7 +545,7 @@ module ActiveRecord #:nodoc:
       #   customer.credit_rating = "Average"
       #   customer.credit_rating # => "Average"
       def attr_protected(*attributes)
-        write_inheritable_array("attr_protected", attributes)
+        write_inheritable_array("attr_protected", attributes - (protected_attributes || []))
       end
 
       # Returns an array of all the attributes that have been protected from mass-assignment.
@@ -505,12 +553,12 @@ module ActiveRecord #:nodoc:
         read_inheritable_attribute("attr_protected")
       end
 
-      # If this macro is used, only those attributed named in it will be accessible for mass-assignment, such as
+      # If this macro is used, only those attributes named in it will be accessible for mass-assignment, such as
       # <tt>new(attributes)</tt> and <tt>attributes=(attributes)</tt>. This is the more conservative choice for mass-assignment
       # protection. If you'd rather start from an all-open default and restrict attributes as needed, have a look at
       # attr_protected.
       def attr_accessible(*attributes)
-        write_inheritable_array("attr_accessible", attributes)
+        write_inheritable_array("attr_accessible", attributes - (accessible_attributes || []))
       end
 
       # Returns an array of all the attributes that have been made accessible to mass-assignment.
@@ -545,20 +593,31 @@ module ActiveRecord #:nodoc:
       #      set_table_name "mice"
       #   end
       def table_name
-        "#{table_name_prefix}#{undecorated_table_name(class_name_of_active_record_descendant(self))}#{table_name_suffix}"
+        reset_table_name
+      end
+
+      def reset_table_name
+        name = "#{table_name_prefix}#{undecorated_table_name(class_name_of_active_record_descendant(self))}#{table_name_suffix}"
+        set_table_name name
+        name
       end
 
       # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the
       # primary_key_prefix_type setting, though.
       def primary_key
+        reset_primary_key
+      end
+
+      def reset_primary_key
+        key = 'id'
         case primary_key_prefix_type
           when :table_name
-            Inflector.foreign_key(class_name_of_active_record_descendant(self), false)
+            key = Inflector.foreign_key(class_name_of_active_record_descendant(self), false)
           when :table_name_with_underscore
-            Inflector.foreign_key(class_name_of_active_record_descendant(self))
-          else
-            "id"
+            key = Inflector.foreign_key(class_name_of_active_record_descendant(self))
         end
+        set_primary_key(key)
+        key
       end
 
       # Defines the column name for use with single table inheritance -- can be overridden in subclasses.
@@ -566,6 +625,11 @@ module ActiveRecord #:nodoc:
         "type"
       end
 
+      # Default sequence_name.  Use set_sequence_name to override.
+      def sequence_name
+        connection.default_sequence_name(table_name, primary_key)
+      end
+
       # Sets the table name to use to the given value, or (if the value
       # is nil or false) to the value returned by the given block.
       #
@@ -609,6 +673,25 @@ module ActiveRecord #:nodoc:
       end
       alias :inheritance_column= :set_inheritance_column
 
+      # Sets the name of the sequence to use when generating ids to the given
+      # value, or (if the value is nil or false) to the value returned by the
+      # 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
+      #
+      # Example:
+      #
+      #   class Project < ActiveRecord::Base
+      #     set_sequence_name "projectseq"   # default would have been "project_seq"
+      #   end
+      def set_sequence_name( value=nil, &block )
+        define_attr_method :sequence_name, value, &block
+      end
+      alias :sequence_name= :set_sequence_name
+
       # Turns the +table_name+ back into a class name following the reverse rules of +table_name+.
       def class_name(table_name = table_name) # :nodoc:
         # remove any prefix and/or suffix from the table name
@@ -619,7 +702,11 @@ module ActiveRecord #:nodoc:
 
       # Returns an array of column objects for the table associated with this class.
       def columns
-        @columns ||= connection.columns(table_name, "#{name} Columns")
+        unless @columns
+          @columns = connection.columns(table_name, "#{name} Columns")
+          @columns.each {|column| column.primary = column.name == primary_key}
+        end
+        @columns
       end
 
       # Returns an array of column objects for the table associated with this class.
@@ -631,10 +718,10 @@ module ActiveRecord #:nodoc:
         @column_names ||= columns.map { |column| column.name }
       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.
+      # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
+      # and columns used for single table inheritance have been removed.
       def content_columns
-        @content_columns ||= columns.reject { |c| c.name == primary_key || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
+        @content_columns ||= columns.reject { |c| c.primary || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
       end
 
       # Returns a hash of all the methods added to query each of the columns in the table with the name of the method as the key
@@ -650,9 +737,16 @@ module ActiveRecord #:nodoc:
         end
       end
 
-      # Resets all the cached information about columns, which will cause they to be reloaded on the next request.
+    
+      # Contains the names of the generated reader methods.
+      def read_methods
+        @read_methods ||= {}
+      end
+      
+      # Resets all the cached information about columns, which will cause them to be reloaded on the next request.
       def reset_column_information
-        @column_names = @columns = @columns_hash = @content_columns = @dynamic_methods_hash = nil
+        read_methods.each_key {|name| undef_method(name)}
+        @column_names = @columns = @columns_hash = @content_columns = @dynamic_methods_hash = @read_methods = nil
       end
 
       def reset_column_information_and_inheritable_attributes_for_all_subclasses#:nodoc:
@@ -679,19 +773,28 @@ module ActiveRecord #:nodoc:
         connection.quote(object)
       end
 
-      # Log and benchmark multiple statements in a single block.
-      # Usage (hides all the SQL calls for the individual actions and calculates total runtime for them all):
+      # Log and benchmark multiple statements in a single block. Example:
       #
       #   Project.benchmark("Creating project") do
       #     project = Project.create("name" => "stuff")
       #     project.create_manager("name" => "David")
       #     project.milestones << Milestone.find(:all)
       #   end
-      def benchmark(title)
-        result = nil
-        seconds = Benchmark.realtime { result = silence { yield } }
-        logger.info "#{title} (#{sprintf("%f", seconds)})" if logger
-        return result
+      #
+      # The benchmark is only recorded if the current level of the logger matches the <tt>log_level</tt>, which makes it
+      # easy to include benchmarking statements in production software that will remain inexpensive because the benchmark
+      # will only be conducted if the log level is low enough.
+      #
+      # The logging of the multiple statements is turned off unless <tt>use_silence</tt> is set to false.
+      def benchmark(title, log_level = Logger::DEBUG, use_silence = true)
+        if logger && logger.level == log_level
+          result = nil
+          seconds = Benchmark.realtime { result = use_silence ? silence { yield } : yield }
+          logger.add(log_level, "#{title} (#{'%.5f' % seconds})")
+          result
+        else
+          yield
+        end
       end
 
       # Silences the logger for the duration of the block.
@@ -701,48 +804,77 @@ module ActiveRecord #:nodoc:
       ensure
         logger.level = old_logger_level if logger
       end
+      
+      # Add constraints to all queries to the same model in the given block.
+      # Currently supported constraints are <tt>:conditions</tt> and <tt>:joins</tt> 
+      #
+      #   Article.constrain(:conditions => "blog_id = 1") do
+      #     Article.find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1
+      #   end
+      def constrain(options = {}, &block)
+        begin
+          self.scope_constraints = options
+          block.call if block_given?
+        ensure 
+          self.scope_constraints = nil
+        end
+      end
 
       # Overwrite the default class equality method to provide support for association proxies.
       def ===(object)
         object.is_a?(self)
+      end      
+
+      # Deprecated 
+      def threaded_connections
+        allow_concurrency
       end
 
+      # Deprecated 
+      def threaded_connections=(value)
+        self.allow_concurrency = value
+      end
+
+      
       private
         # Finder methods must instantiate through this method to work with the single-table inheritance model
         # that makes it possible to create objects of different types from the same table.
         def instantiate(record)
-          subclass_name = record[inheritance_column]
-          require_association_class(subclass_name)
-
-          object = if subclass_name.blank?
-            allocate
-          else
-            begin
-              compute_type(subclass_name).allocate
-            rescue NameError
-              raise SubclassNotFound,
-                "The single-table inheritance mechanism failed to locate the subclass: '#{record[inheritance_column]}'. " +
-                "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
-                "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
-                "or overwrite #{self.to_s}.inheritance_column to use another column for that information."
+          object = 
+            if subclass_name = record[inheritance_column]
+              if subclass_name.empty?
+                allocate
+              else
+                require_association_class(subclass_name)
+                begin
+                  compute_type(subclass_name).allocate
+                rescue NameError
+                  raise SubclassNotFound,
+                    "The single-table inheritance mechanism failed to locate the subclass: '#{record[inheritance_column]}'. " +
+                    "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
+                    "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+                    "or overwrite #{self.to_s}.inheritance_column to use another column for that information."
+                end
+              end
+            else
+              allocate
             end
-          end
 
           object.instance_variable_set("@attributes", record)
           object
         end
 
         # Returns the name of the type of the record using the current module as a prefix. So descendents of
-        # MyApp::Business::Account would be appear as "MyApp::Business::AccountSubclass".
+        # MyApp::Business::Account would appear as "MyApp::Business::AccountSubclass".
         def type_name_with_module(type_name)
           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]
+          sql  = "SELECT #{options[:select] || '*'} FROM #{table_name} "
+          add_joins!(sql, options)
           add_conditions!(sql, options[:conditions])
-          sql << "ORDER BY #{options[:order]} " if options[:order]
+          sql << " ORDER BY #{options[:order]} " if options[:order]
           add_limit!(sql, options)
           sql
         end
@@ -750,11 +882,19 @@ module ActiveRecord #:nodoc:
         def add_limit!(sql, options)
           connection.add_limit_offset!(sql, options)
         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?
-          sql << (conditions.nil? ? "WHERE " : " AND ") + type_condition unless descends_from_active_record?
+        
+        def add_joins!(sql, options)
+          join = scope_constraints[:joins] || options[:joins]
+          sql << " #{join} " if join
+        end
+        
+        # Adds a sanitized version of +conditions+ to the +sql+ string. Note that the passed-in +sql+ string is changed.
+        def add_conditions!(sql, conditions)          
+          condition_segments = [scope_constraints[:conditions]]
+          condition_segments << sanitize_sql(conditions) unless conditions.nil?
+          condition_segments << type_condition unless descends_from_active_record?        
+          condition_segments.compact!
+          sql << "WHERE (#{condition_segments.join(") AND (")}) " unless condition_segments.empty?
         end
 
         def type_condition
@@ -787,7 +927,7 @@ module ActiveRecord #:nodoc:
             attributes.each { |attr_name| super unless column_methods_hash.include?(attr_name.to_sym) }
 
             attr_index = -1
-            conditions = attributes.collect { |attr_name| attr_index += 1; "#{attr_name} #{attribute_condition(arguments[attr_index])} " }.join(" AND ")
+            conditions = attributes.collect { |attr_name| attr_index += 1; "#{table_name}.#{attr_name} #{attribute_condition(arguments[attr_index])} " }.join(" AND ")
 
             if arguments[attributes.length].is_a?(Hash)
               find(finder, { :conditions => [conditions, *arguments[0...attributes.length]] }.update(arguments[attributes.length]))
@@ -828,9 +968,14 @@ module ActiveRecord #:nodoc:
         #   end
         def define_attr_method(name, value=nil, &block)
           sing = class << self; self; end
-          block = proc { value.to_s } if value
-          sing.send( :alias_method, "original_#{name}", name )
-          sing.send( :define_method, name, &block )
+          sing.send :alias_method, "original_#{name}", name
+          if value
+            # 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
 
       protected
@@ -838,9 +983,31 @@ module ActiveRecord #:nodoc:
           @@subclasses[self] ||= []
           @@subclasses[self] + extra = @@subclasses[self].inject([]) {|list, subclass| list + subclass.subclasses }
         end
+        
+        def scope_constraints
+          if allow_concurrency
+            Thread.current[:constraints] ||= {}
+            Thread.current[:constraints][self] ||= {}
+          else
+            @scope_constraints ||= {}
+          end
+        end
+        # backwards compatibility
+        alias_method :scope_constrains, :scope_constraints 
 
+        def scope_constraints=(value)
+          if allow_concurrency
+            Thread.current[:constraints] ||= {}
+            Thread.current[:constraints][self] = value
+          else
+            @scope_constraints = value
+          end
+        end
+        # backwards compatibility
+        alias_method :scope_constrains=, :scope_constraints=
+        
         # Returns the class type of the record using the current module as a prefix. So descendents of
-        # MyApp::Business::Account would be appear as MyApp::Business::AccountSubclass.
+        # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)
           type_name_with_module(type_name).split("::").inject(Object) do |final_type, part|
             final_type.const_get(part)
@@ -909,7 +1076,13 @@ module ActiveRecord #:nodoc:
         end
 
         def extract_options_from_args!(args)
-          if args.last.is_a?(Hash) then args.pop else {} end
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          validate_find_options(options)
+          options
+        end
+
+        def validate_find_options(options)
+          options.assert_valid_keys [:conditions, :include, :joins, :limit, :offset, :order, :select, :readonly]
         end
 
         def encode_quoted_value(value)
@@ -935,7 +1108,10 @@ module ActiveRecord #:nodoc:
       # Every Active Record class must use "id" as their primary ID. This getter overwrites the native
       # id method, which isn't being used in this context.
       def id
-        read_attribute(self.class.primary_key)
+        attr_name = self.class.primary_key
+        column    = column_for_attribute(attr_name)
+        define_read_method(:id, attr_name, column) if self.class.generate_read_methods
+        (value = @attributes[attr_name]) && column.type_cast(value)
       end
 
       # Enables Active Record objects to be used as URL parameters in Action Pack automatically.
@@ -962,6 +1138,7 @@ module ActiveRecord #:nodoc:
       # * No record exists: Creates a new record with values matching those of the object attributes.
       # * A record does exist: Updates the record with values matching those of the object attributes.
       def save
+        raise ActiveRecord::ReadOnlyRecord if readonly?
         create_or_update
       end
 
@@ -991,11 +1168,11 @@ module ActiveRecord #:nodoc:
       # Note: This method is overwritten by the Validation module that'll make sure that updates made with this method
       # doesn't get subjected to validation checks. Hence, attributes can be updated even if the full object isn't valid.
       def update_attribute(name, value)
-        self[name] = value
+        send(name.to_s + '=', value)
         save
       end
 
-      # Updates all the attributes in from the passed hash and saves the record. If the object is invalid, the saving will
+      # Updates all the attributes from the passed-in Hash and saves the record. If the object is invalid, the saving will
       # fail and false will be returned.
       def update_attributes(attributes)
         self.attributes = attributes
@@ -1028,7 +1205,7 @@ module ActiveRecord #:nodoc:
 
       # Turns an +attribute+ that's currently true into false and vice versa. Returns self.
       def toggle(attribute)
-        self[attribute] = quote(!send("#{attribute}?", column_for_attribute(attribute)))
+        self[attribute] = !send("#{attribute}?")
         self
       end
 
@@ -1044,17 +1221,17 @@ module ActiveRecord #:nodoc:
         self
       end
 
-      # Returns the value of attribute identified by <tt>attr_name</tt> after it has been type cast (for example,
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
       # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
       # (Alias for the protected read_attribute method).
       def [](attr_name)
-        read_attribute(attr_name.to_s)
+        read_attribute(attr_name)
       end
 
       # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
       # (Alias for the protected write_attribute method).
       def []=(attr_name, value)
-        write_attribute(attr_name.to_s, value)
+        write_attribute(attr_name, value)
       end
 
       # Allows you to set all the attributes at once by passing in a hash with keys
@@ -1084,7 +1261,7 @@ module ActiveRecord #:nodoc:
       end
 
       # Returns true if the specified +attribute+ has been set by the user or by a database load and is neither
-      # nil nor empty? (the latter only applies to objects that responds to empty?, most notably Strings).
+      # nil nor empty? (the latter only applies to objects that respond to empty?, most notably Strings).
       def attribute_present?(attribute)
         value = read_attribute(attribute)
         !value.blank? or value == 0
@@ -1102,7 +1279,10 @@ module ActiveRecord #:nodoc:
 
       # Returns true if the +comparison_object+ is the same object, or is of the same type and has the same id.
       def ==(comparison_object)
-        comparison_object.equal?(self) or (comparison_object.instance_of?(self.class) and comparison_object.id == id)
+        comparison_object.equal?(self) ||
+          (comparison_object.instance_of?(self.class) && 
+            comparison_object.id == id && 
+            !comparison_object.new_record?)
       end
 
       # Delegates to ==
@@ -1127,20 +1307,27 @@ module ActiveRecord #:nodoc:
 
       # Just freeze the attributes hash, such that associations are still accessible even on destroyed records.
       def freeze
-        @attributes.freeze
+        @attributes.freeze; self
       end
 
       def frozen?
         @attributes.frozen?
       end
 
+      def readonly?
+        @readonly == true
+      end
+
+      def readonly!
+        @readonly = true
+      end
+
     private
       def create_or_update
         if new_record? then create else update end
-        true
       end
 
-      # Updates the associated record with values matching those of the instant attributes.
+      # Updates the associated record with values matching those of the instance attributes.
       def update
         connection.update(
           "UPDATE #{self.class.table_name} " +
@@ -1150,20 +1337,20 @@ module ActiveRecord #:nodoc:
         )
       end
 
-      # Creates a new record with values matching those of the instant attributes.
+      # Creates a new record with values matching those of the instance attributes.
       def create
         self.id = connection.insert(
           "INSERT INTO #{self.class.table_name} " +
           "(#{quoted_column_names.join(', ')}) " +
           "VALUES(#{attributes_with_quotes.values.join(', ')})",
           "#{self.class.name} Create",
-          self.class.primary_key, self.id
+          self.class.primary_key, self.id, self.class.sequence_name
         )
 
         @new_record = false
       end
 
-      # Sets the attribute used for single table inheritance to this class name if this is not the ActiveRecord descendant.
+      # Sets the attribute used for single table inheritance to this class name if this is not the ActiveRecord descendent.
       # Considering the hierarchy Reply < Message < ActiveRecord, this makes it possible to do Reply.new without having to
       # set Reply[Reply.inheritance_column] = "Reply" yourself. No such attribute would be set for objects of the
       # Message class in that example.
@@ -1184,7 +1371,10 @@ module ActiveRecord #:nodoc:
       def method_missing(method_id, *args, &block)
         method_name = method_id.to_s
         if @attributes.include?(method_name)
+          define_read_methods if self.class.read_methods.empty? && self.class.generate_read_methods
           read_attribute(method_name)
+        elsif self.class.primary_key.to_s == method_name
+          id
         elsif md = /(=|\?|_before_type_cast)$/.match(method_name)
           attribute_name, method_type = md.pre_match, md.to_s
           if @attributes.include?(attribute_name)
@@ -1204,9 +1394,10 @@ module ActiveRecord #:nodoc:
         end
       end
 
-      # Returns the value of attribute identified by <tt>attr_name</tt> after it has been type cast (for example,
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
       # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name)
+        attr_name = attr_name.to_s
         if !(value = @attributes[attr_name]).nil?
           if column = column_for_attribute(attr_name)
             if unserializable_attribute?(attr_name, column)
@@ -1226,11 +1417,36 @@ module ActiveRecord #:nodoc:
         @attributes[attr_name]
       end
 
+      # Called on first read access to any given column and generates reader
+      # methods for all columns in the columns_hash if
+      # ActiveRecord::Base.generate_read_methods is set to true.
+      def define_read_methods
+        self.class.columns_hash.each do |name, column|
+          unless column.primary || self.class.serialized_attributes[name] || respond_to_without_attributes?(name)
+            define_read_method(name.to_sym, name, column)
+          end
+        end
+      end
+
+      # Define a column type specific reader method.
+      def define_read_method(symbol, attr_name, column)
+        cast_code = column.type_cast_code('v')
+        access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
+        body = access_code
+
+        # The following 3 lines behave exactly like method_missing if the
+        # attribute isn't present.
+        unless symbol == :id
+          body = body.insert(0, "raise NoMethodError, 'missing attribute: #{attr_name}', caller unless @attributes.has_key?('#{attr_name}'); ")
+        end
+        self.class.class_eval("def #{symbol}; #{body} end")
+
+        self.class.read_methods[attr_name] = true unless symbol == :id
+      end
+
       # Returns true if the attribute is of a text column and marked for serialization.
       def unserializable_attribute?(attr_name, column)
-        if value = @attributes[attr_name]
-          [:text, :string].include?(column.send(:type)) && value.is_a?(String) && self.class.serialized_attributes[attr_name]
-        end
+        column.text? && self.class.serialized_attributes[attr_name]
       end
 
       # Returns the unserialized object of the attribute.
@@ -1248,12 +1464,21 @@ module ActiveRecord #:nodoc:
       # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings for fixnum and float
       # columns are turned into nil.
       def write_attribute(attr_name, value)
-        @attributes[attr_name.to_s] = empty_string_for_number_column?(attr_name.to_s, value) ? nil : value
+        attr_name = attr_name.to_s
+        if (column = column_for_attribute(attr_name)) && column.number?
+          @attributes[attr_name] = convert_number_column_value(value)
+        else
+          @attributes[attr_name] = value
+        end
       end
 
-      def empty_string_for_number_column?(attr_name, value)
-        column = column_for_attribute(attr_name)
-        column && (column.klass == Fixnum || column.klass == Float) && value == ""
+      def convert_number_column_value(value)
+        case value
+          when FalseClass: 0
+          when TrueClass:  1
+          when '':         nil
+          else value
+        end
       end
 
       def query_attribute(attr_name)
@@ -1289,7 +1514,9 @@ module ActiveRecord #:nodoc:
 
       # The primary key and inheritance column can never be set by mass-assignment for security reasons.
       def attributes_protected_by_default
-        [ self.class.primary_key, self.class.inheritance_column ]
+        default = [ self.class.primary_key, self.class.inheritance_column ]
+        default << 'id' unless self.class.primary_key.eql? 'id'
+        default
       end
 
       # Returns copy of the attributes hash where all the values have been safely quoted for use in
@@ -1297,7 +1524,7 @@ module ActiveRecord #:nodoc:
       def attributes_with_quotes(include_primary_key = true)
         attributes.inject({}) do |quoted, (name, value)|
           if column = column_for_attribute(name)
-            quoted[name] = quote(value, column) unless !include_primary_key && name == self.class.primary_key
+            quoted[name] = quote(value, column) unless !include_primary_key && column.primary
           end
           quoted
         end
@@ -1311,7 +1538,7 @@ module ActiveRecord #:nodoc:
       # Interpolate custom sql string in instance context.
       # Optional record argument is meant for custom insert_sql.
       def interpolate_sql(sql, record = nil)
-        instance_eval("%(#{sql})")
+        instance_eval("%@#{sql.gsub('@', '\@')}@")
       end
 
       # Initializes the attributes array with keys matching the columns from the linked table and
@@ -1319,7 +1546,7 @@ module ActiveRecord #:nodoc:
       # that a new instance, or one populated from a passed-in Hash, still has all the attributes
       # that instances loaded from the database would.
       def attributes_from_column_definition
-        connection.columns(self.class.table_name, "#{self.class.name} Columns").inject({}) do |attributes, column|
+        self.class.columns.inject({}) do |attributes, column|
           attributes[column.name] = column.default unless column.name == self.class.primary_key
           attributes
         end
@@ -1406,20 +1633,7 @@ module ActiveRecord #:nodoc:
 
       def object_from_yaml(string)
         return string unless string.is_a?(String)
-        if has_yaml_encoding_header?(string)
-          begin
-            YAML::load(string)
-          rescue Object
-            # Apparently wasn't YAML anyway
-            string
-          end
-        else
-          string
-        end
-      end
-
-      def has_yaml_encoding_header?(string)
-        string[0..3] == "--- "
+        YAML::load(string) rescue string
       end
 
       def clone_attributes(reader_method = :read_attribute, attributes = {})