activerecord 3.1.0.rc5 → 3.1.0.rc6

data/CHANGELOG

@@ -1,5 +1,11 @@
 *Rails 3.1.0 (unreleased)*
 
+* Add a proxy_association method to association proxies, which can be called by association
+  extensions to access information about the association. This replaces proxy_owner etc with
+  proxy_association.owner.
+
+  [Jon Leighton]
+
 * Active Record's dynamic finder will now show a deprecation warning if you passing in less number of arguments than what you call in method signature. This behavior will raise ArgumentError in the next version of Rails [Prem Sichanugrist]
 
 * Deprecated the AssociationCollection constant. CollectionProxy is now the appropriate constant

data/README.rdoc

@@ -203,7 +203,7 @@ The latest version of Active Record can be installed with Rubygems:
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/master/activerecord/
+* https://github.com/rails/rails/tree/master/activerecord
 
 
 == License

data/lib/active_record/associations.rb

@@ -467,6 +467,12 @@ module ActiveRecord
     # * <tt>record.association(:items).target</tt> - Returns the associated object for +belongs_to+ and +has_one+, or
     #   the collection of associated objects for +has_many+ and +has_and_belongs_to_many+.
     #
+    # However, inside the actual extension code, you will not have access to the <tt>record</tt> as
+    # above. In this case, you can access <tt>proxy_association</tt>. For example,
+    # <tt>record.association(:items)</tt> and <tt>record.items.proxy_association</tt> will return
+    # the same object, allowing you to make calls like <tt>proxy_association.owner</tt> inside
+    # association extensions.
+    #
     # === Association Join Models
     #
     # Has Many associations can be configured with the <tt>:through</tt> option to use an

data/lib/active_record/associations/association.rb

@@ -152,20 +152,20 @@ module ActiveRecord
         reset
       end
 
+      def interpolate(sql, record = nil)
+        if sql.respond_to?(:to_proc)
+          owner.send(:instance_exec, record, &sql)
+        else
+          sql
+        end
+      end
+
       private
 
         def find_target?
           !loaded? && (!owner.new_record? || foreign_key_present?) && klass
         end
 
-        def interpolate(sql, record = nil)
-          if sql.respond_to?(:to_proc)
-            owner.send(:instance_exec, record, &sql)
-          else
-            sql
-          end
-        end
-
         def creation_attributes
           attributes = {}
 

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -2,6 +2,11 @@ module ActiveRecord
   # = Active Record Belongs To Polymorphic Association
   module Associations
     class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
+      def klass
+        type = owner[reflection.foreign_type]
+        type.presence && type.constantize
+      end
+
       private
 
         def replace_keys(record)
@@ -17,11 +22,6 @@ module ActiveRecord
           reflection.polymorphic_inverse_of(record.class)
         end
 
-        def klass
-          type = owner[reflection.foreign_type]
-          type.presence && type.constantize
-        end
-
         def raise_on_type_mismatch(record)
           # A polymorphic association cannot have a type mismatch, by definition
         end

data/lib/active_record/associations/collection_association.rb

@@ -114,13 +114,19 @@ module ActiveRecord
       # Add +records+ to this association.  Returns +self+ so method calls may be chained.
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
+        result = true
         load_target if owner.new_record?
 
-        if owner.new_record?
-          concat_records(records)
-        else
-          transaction { concat_records(records) }
+        transaction do
+          records.flatten.each do |record|
+            raise_on_type_mismatch(record)
+            add_to_target(record) do |r|
+              result &&= insert_record(record) unless owner.new_record?
+            end
+          end
         end
+
+        result && records
       end
 
       # Starts a transaction in the association class's database connection.
@@ -289,10 +295,14 @@ module ActiveRecord
         other_array.each { |val| raise_on_type_mismatch(val) }
         original_target = load_target.dup
 
-        if owner.new_record?
-          replace_records(other_array, original_target)
-        else
-          transaction { replace_records(other_array, original_target) }
+        transaction do
+          delete(target - other_array)
+
+          unless concat(other_array - target)
+            @target = original_target
+            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                  "new records could not be saved."
+          end
         end
       end
 
@@ -428,20 +438,14 @@ module ActiveRecord
           records.each { |record| raise_on_type_mismatch(record) }
           existing_records = records.reject { |r| r.new_record? }
 
-          if existing_records.empty?
-            remove_records(existing_records, records, method)
-          else
-            transaction { remove_records(existing_records, records, method) }
-          end
-        end
-
-        def remove_records(existing_records, records, method)
-          records.each { |record| callback(:before_remove, record) }
+          transaction do
+            records.each { |record| callback(:before_remove, record) }
 
-          delete_records(existing_records, method) if existing_records.any?
-          records.each { |record| target.delete(record) }
+            delete_records(existing_records, method) if existing_records.any?
+            records.each { |record| target.delete(record) }
 
-          records.each { |record| callback(:after_remove, record) }
+            records.each { |record| callback(:after_remove, record) }
+          end
         end
 
         # Delete the given records from the association, using one of the methods :destroy,
@@ -450,29 +454,6 @@ module ActiveRecord
           raise NotImplementedError
         end
 
-        def replace_records(new_target, original_target)
-          delete(target - new_target)
-
-          unless concat(new_target - target)
-            @target = original_target
-            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
-                                  "new records could not be saved."
-          end
-        end
-
-        def concat_records(records)
-          result = true
-
-          records.flatten.each do |record|
-            raise_on_type_mismatch(record)
-            add_to_target(record) do |r|
-              result &&= insert_record(record) unless owner.new_record?
-            end
-          end
-
-          result && records
-        end
-
         def callback(method, record)
           callbacks_for(method).each do |callback|
             case callback

data/lib/active_record/associations/collection_proxy.rb

@@ -65,23 +65,27 @@ module ActiveRecord
 
       alias_method :new, :build
 
+      def proxy_association
+        @association
+      end
+
       def respond_to?(name, include_private = false)
         super ||
         (load_target && target.respond_to?(name, include_private)) ||
-        @association.klass.respond_to?(name, include_private)
+        proxy_association.klass.respond_to?(name, include_private)
       end
 
       def method_missing(method, *args, &block)
         match = DynamicFinderMatch.match(method)
         if match && match.instantiator?
           record = send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
-            @association.send :set_owner_attributes, r
-            @association.send :add_to_target, r
+            proxy_association.send :set_owner_attributes, r
+            proxy_association.send :add_to_target, r
             yield(r) if block_given?
           end
         end
 
-        if target.respond_to?(method) || (!@association.klass.respond_to?(method) && Class.respond_to?(method))
+        if target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
           if load_target
             if target.respond_to?(method)
               target.send(method, *args, &block)
@@ -111,7 +115,7 @@ module ActiveRecord
       alias_method :to_a, :to_ary
 
       def <<(*records)
-        @association.concat(records) && self
+        proxy_association.concat(records) && self
       end
       alias_method :push, :<<
 
@@ -121,32 +125,35 @@ module ActiveRecord
       end
 
       def reload
-        @association.reload
+        proxy_association.reload
         self
       end
 
       def proxy_owner
         ActiveSupport::Deprecation.warn(
           "Calling record.#{@association.reflection.name}.proxy_owner is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).owner instead."
+          "record.association(:#{@association.reflection.name}).owner instead. Or, from an " \
+          "association extension you can access proxy_association.owner."
         )
-        @association.owner
+        proxy_association.owner
       end
 
       def proxy_target
         ActiveSupport::Deprecation.warn(
           "Calling record.#{@association.reflection.name}.proxy_target is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).target instead."
+          "record.association(:#{@association.reflection.name}).target instead. Or, from an " \
+          "association extension you can access proxy_association.target."
         )
-        @association.target
+        proxy_association.target
       end
 
       def proxy_reflection
         ActiveSupport::Deprecation.warn(
           "Calling record.#{@association.reflection.name}.proxy_reflection is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).reflection instead."
+          "record.association(:#{@association.reflection.name}).reflection instead. Or, from an " \
+          "association extension you can access proxy_association.reflection."
         )
-        @association.reflection
+        proxy_association.reflection
       end
     end
   end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -26,7 +26,7 @@ module ActiveRecord
             join_table[reflection.association_foreign_key] => record.id
           )
 
-          owner.connection.insert stmt.to_sql
+          owner.connection.insert stmt
         end
 
         record
@@ -46,7 +46,7 @@ module ActiveRecord
             stmt = relation.where(relation[reflection.foreign_key].eq(owner.id).
               and(relation[reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
             ).compile_delete
-            owner.connection.delete stmt.to_sql
+            owner.connection.delete stmt
           end
         end
 

data/lib/active_record/associations/join_dependency.rb

@@ -188,13 +188,12 @@ module ActiveRecord
           association = join_part.instantiate(row) unless row[join_part.aliased_primary_key].nil?
           set_target_and_inverse(join_part, association, record)
         else
-          return if row[join_part.aliased_primary_key].nil?
-          association = join_part.instantiate(row)
+          association = join_part.instantiate(row) unless row[join_part.aliased_primary_key].nil?
           case macro
           when :has_many, :has_and_belongs_to_many
             other = record.association(join_part.reflection.name)
             other.loaded!
-            other.target.push(association)
+            other.target.push(association) if association
             other.set_inverse_instance(association)
           when :belongs_to
             set_target_and_inverse(join_part, association, record)

data/lib/active_record/associations/preloader/has_and_belongs_to_many.rb

@@ -13,7 +13,7 @@ module ActiveRecord
         # access the aliased column on the join table
         def records_for(ids)
           scope = super
-          klass.connection.select_all(scope.arel.to_sql, 'SQL', scope.bind_values)
+          klass.connection.select_all(scope.arel, 'SQL', scope.bind_values)
         end
 
         def owner_key_name

data/lib/active_record/attribute_methods/primary_key.rb

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

data/lib/active_record/base.rb

@@ -940,17 +940,6 @@ module ActiveRecord #:nodoc:
         self.current_scope = nil
       end
 
-      # Specifies how the record is loaded by +Marshal+.
-      #
-      # +_load+ sets an instance variable for each key in the hash it takes as input.
-      # Override this method if you require more complex marshalling.
-      def _load(data)
-        record = allocate
-        record.init_with(Marshal.load(data))
-        record
-      end
-
-
       # 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.
@@ -1057,12 +1046,10 @@ module ActiveRecord #:nodoc:
           if match = DynamicFinderMatch.match(method_id)
             attribute_names = match.attribute_names
             super unless all_attributes_exists?(attribute_names)
-            if arguments.size < attribute_names.size
-              ActiveSupport::Deprecation.warn(
-                "Calling dynamic finder with less number of arguments than the number of attributes in " \
-                "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
-                "Please passing `nil' to the argument you want it to be nil."
-              )
+            if !arguments.first.is_a?(Hash) && arguments.size < attribute_names.size
+              ActiveSupport::Deprecation.warn(<<-eowarn)
+Calling dynamic finder with less number of arguments than the number of attributes in method name is deprecated and will raise an ArguementError in the next version of Rails. Please passing `nil' to the argument you want it to be nil.
+                eowarn
             end
             if match.finder?
               options = arguments.extract_options!
@@ -1283,27 +1270,43 @@ MSG
           self.default_scopes = default_scopes + [scope]
         end
 
-        # The @ignore_default_scope flag is used to prevent an infinite recursion situation where
-        # a default scope references a scope which has a default scope which references a scope...
         def build_default_scope #:nodoc:
-          return if defined?(@ignore_default_scope) && @ignore_default_scope
-          @ignore_default_scope = true
-
           if method(:default_scope).owner != Base.singleton_class
-            default_scope
+            evaluate_default_scope { default_scope }
           elsif default_scopes.any?
-            default_scopes.inject(relation) do |default_scope, scope|
-              if scope.is_a?(Hash)
-                default_scope.apply_finder_options(scope)
-              elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
-                default_scope.merge(scope.call)
-              else
-                default_scope.merge(scope)
+            evaluate_default_scope do
+              default_scopes.inject(relation) do |default_scope, scope|
+                if scope.is_a?(Hash)
+                  default_scope.apply_finder_options(scope)
+                elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
+                  default_scope.merge(scope.call)
+                else
+                  default_scope.merge(scope)
+                end
               end
             end
           end
-        ensure
-          @ignore_default_scope = false
+        end
+
+        def ignore_default_scope? #:nodoc:
+          Thread.current["#{self}_ignore_default_scope"]
+        end
+
+        def ignore_default_scope=(ignore) #:nodoc:
+          Thread.current["#{self}_ignore_default_scope"] = ignore
+        end
+
+        # The ignore_default_scope flag is used to prevent an infinite recursion situation where
+        # a default scope references a scope which has a default scope which references a scope...
+        def evaluate_default_scope
+          return if ignore_default_scope?
+
+          begin
+            self.ignore_default_scope = true
+            yield
+          ensure
+            self.ignore_default_scope = false
+          end
         end
 
         # Returns the class type of the record using the current module as a prefix. So descendants of
@@ -1425,9 +1428,8 @@ MSG
           attrs = expand_hash_conditions_for_aggregates(attrs)
 
           table = Arel::Table.new(table_name).alias(default_table_name)
-          viz = Arel::Visitors.for(arel_engine)
           PredicateBuilder.build_from_hash(arel_engine, attrs, table).map { |b|
-            viz.accept b
+            connection.visitor.accept b
           }.join(' AND ')
         end
         alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
@@ -1605,16 +1607,6 @@ MSG
         self
       end
 
-      # Specifies how the record is dumped by +Marshal+.
-      #
-      # +_dump+ emits a marshalled hash which has been passed to +encode_with+. Override this
-      # method if you require more complex marshalling.
-      def _dump(level)
-        dump = {}
-        encode_with(dump)
-        Marshal.dump(dump)
-      end
-
       # Returns a String, which Action Pack uses for constructing an URL to this
       # object. The default implementation returns this record's id as a String,
       # or nil if this record's unsaved.

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

@@ -82,10 +82,11 @@ module ActiveRecord
         # default max pool size to 5
         @size = (spec.config[:pool] && spec.config[:pool].to_i) || 5
 
-        @connections = []
-        @checked_out = []
+        @connections         = []
+        @checked_out         = []
         @automatic_reconnect = true
-        @tables = {}
+        @tables              = {}
+        @visitor             = nil
 
         @columns     = Hash.new do |h, table_name|
           h[table_name] = with_connection do |conn|
@@ -298,8 +299,18 @@ module ActiveRecord
         :connected?, :disconnect!, :with => :@connection_mutex
 
       private
+
       def new_connection
-        ActiveRecord::Base.send(spec.adapter_method, spec.config)
+        connection = ActiveRecord::Base.send(spec.adapter_method, spec.config)
+
+        # TODO: This is a bit icky, and in the long term we may want to change the method
+        #       signature for connections. Also, if we switch to have one visitor per
+        #       connection (and therefore per thread), we can get rid of the thread-local
+        #       variable in Arel::Visitors::ToSql.
+        @visitor ||= connection.class.visitor_for(self)
+        connection.visitor = @visitor
+
+        connection
       end
 
       def current_connection_id #:nodoc:

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

@@ -3,30 +3,39 @@ require 'active_support/core_ext/module/deprecation'
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseStatements
+      # Converts an arel AST to SQL
+      def to_sql(arel)
+        if arel.respond_to?(:ast)
+          visitor.accept(arel.ast)
+        else
+          arel
+        end
+      end
+
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
-      def select_all(sql, name = nil, binds = [])
-        select(sql, name, binds)
+      def select_all(arel, name = nil, binds = [])
+        select(to_sql(arel), name, binds)
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
-      def select_one(sql, name = nil)
-        result = select_all(sql, name)
+      def select_one(arel, name = nil)
+        result = select_all(arel, name)
         result.first if result
       end
 
       # Returns a single value from a record
-      def select_value(sql, name = nil)
-        if result = select_one(sql, name)
+      def select_value(arel, name = nil)
+        if result = select_one(arel, name)
           result.values.first
         end
       end
 
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
-      def select_values(sql, name = nil)
-        result = select_rows(sql, name)
+      def select_values(arel, name = nil)
+        result = select_rows(to_sql(arel), name)
         result.map { |v| v[0] }
       end
 
@@ -76,20 +85,20 @@ module ActiveRecord
       #
       # If the next id was calculated in advance (as in Oracle), it should be
       # passed in as +id_value+.
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        sql, binds = sql_for_insert(sql, pk, id_value, sequence_name, binds)
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        sql, binds = sql_for_insert(to_sql(arel), pk, id_value, sequence_name, binds)
         value      = exec_insert(sql, name, binds)
         id_value || last_inserted_id(value)
       end
 
       # Executes the update statement and returns the number of rows affected.
-      def update(sql, name = nil, binds = [])
-        exec_update(sql, name, binds)
+      def update(arel, name = nil, binds = [])
+        exec_update(to_sql(arel), name, binds)
       end
 
       # Executes the delete statement and returns the number of rows affected.
-      def delete(sql, name = nil, binds = [])
-        exec_delete(sql, name, binds)
+      def delete(arel, name = nil, binds = [])
+        exec_delete(to_sql(arel), name, binds)
       end
 
       # Checks whether there is currently no transaction active. This is done
@@ -324,6 +333,16 @@ module ActiveRecord
         end
       end
 
+      # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
+      # on mysql (even when aliasing the tables), but mysql allows using JOIN directly in
+      # an UPDATE statement, so in the mysql adapters we redefine this to do that.
+      def join_to_update(update, select) #:nodoc:
+        subselect = select.clone
+        subselect.projections = [update.key]
+
+        update.where update.key.in(subselect)
+      end
+
       protected
         # Returns an array of record hashes with the column names as keys and
         # column values as values.

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

@@ -55,9 +55,10 @@ module ActiveRecord
         @query_cache.clear
       end
 
-      def select_all(sql, name = nil, binds = [])
+      def select_all(arel, name = nil, binds = [])
         if @query_cache_enabled
-          cache_sql(sql, binds) { super }
+          sql = to_sql(arel)
+          cache_sql(sql, binds) { super(sql, name, binds) }
         else
           super
         end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -2,6 +2,7 @@ require 'date'
 require 'bigdecimal'
 require 'bigdecimal/util'
 require 'active_support/core_ext/benchmark'
+require 'active_support/deprecation'
 
 # TODO: Autoload these files
 require 'active_record/connection_adapters/column'
@@ -38,12 +39,33 @@ module ActiveRecord
 
       define_callbacks :checkout, :checkin
 
+      attr_accessor :visitor
+
       def initialize(connection, logger = nil) #:nodoc:
         @active = nil
         @connection, @logger = connection, logger
         @query_cache_enabled = false
         @query_cache = Hash.new { |h,sql| h[sql] = {} }
         @instrumenter = ActiveSupport::Notifications.instrumenter
+        @visitor = nil
+      end
+
+      # Returns a visitor instance for this adaptor, which conforms to the Arel::ToSql interface
+      def self.visitor_for(pool) # :nodoc:
+        adapter = pool.spec.config[:adapter]
+
+        if Arel::Visitors::VISITORS[adapter]
+          ActiveSupport::Deprecation.warn(
+            "Arel::Visitors::VISITORS is deprecated and will be removed. Database adapters " \
+            "should define a visitor_for method which returns the appropriate visitor for " \
+            "the database. For example, MysqlAdapter.visitor_for(pool) returns " \
+            "Arel::Visitors::MySQL.new(pool)."
+          )
+
+          Arel::Visitors::VISITORS[adapter].new(pool)
+        else
+          Arel::Visitors::ToSql.new(pool)
+        end
       end
 
       # Returns the human-readable name of the adapter. Use mixed case - one

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -129,6 +129,10 @@ module ActiveRecord
         configure_connection
       end
 
+      def self.visitor_for(pool) # :nodoc:
+        Arel::Visitors::MySQL.new(pool)
+      end
+
       def adapter_name
         ADAPTER_NAME
       end
@@ -165,7 +169,7 @@ module ActiveRecord
       end
 
       def quote_column_name(name) #:nodoc:
-        @quoted_column_names[name] ||= "`#{name}`"
+        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
       end
 
       def quote_table_name(name) #:nodoc:
@@ -595,6 +599,27 @@ module ActiveRecord
         where_sql
       end
 
+      # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
+      # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
+      # these, we must use a subquery. However, MySQL is too stupid to create a
+      # temporary table for this automatically, so we have to give it some prompting
+      # in the form of a subsubquery. Ugh!
+      def join_to_update(update, select) #:nodoc:
+        if select.limit || select.offset || select.orders.any?
+          subsubselect = select.clone
+          subsubselect.projections = [update.key]
+
+          subselect = Arel::SelectManager.new(select.engine)
+          subselect.project Arel.sql(update.key.name)
+          subselect.from subsubselect.as('__active_record_temp')
+
+          update.where update.key.in(subselect)
+        else
+          update.table select.source
+          update.wheres = select.constraints
+        end
+      end
+
       protected
         def quoted_columns_for_index(column_names, options = {})
           length = options[:length] if options.is_a?(Hash)

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -193,6 +193,10 @@ module ActiveRecord
         connect
       end
 
+      def self.visitor_for(pool) # :nodoc:
+        Arel::Visitors::MySQL.new(pool)
+      end
+
       def adapter_name #:nodoc:
         ADAPTER_NAME
       end
@@ -247,7 +251,7 @@ module ActiveRecord
       end
 
       def quote_column_name(name) #:nodoc:
-        @quoted_column_names[name] ||= "`#{name}`"
+        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
       end
 
       def quote_table_name(name) #:nodoc:
@@ -501,6 +505,27 @@ module ActiveRecord
       end
       deprecate :add_limit_offset!
 
+      # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
+      # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
+      # these, we must use a subquery. However, MySQL is too stupid to create a
+      # temporary table for this automatically, so we have to give it some prompting
+      # in the form of a subsubquery. Ugh!
+      def join_to_update(update, select) #:nodoc:
+        if select.limit || select.offset || select.orders.any?
+          subsubselect = select.clone
+          subsubselect.projections = [update.key]
+
+          subselect = Arel::SelectManager.new(select.engine)
+          subselect.project Arel.sql(update.key.name)
+          subselect.from subsubselect.as('__active_record_temp')
+
+          update.where update.key.in(subselect)
+        else
+          update.table select.source
+          update.wheres = select.constraints
+        end
+      end
+
       # SCHEMA STATEMENTS ========================================
 
       def structure_dump #:nodoc:

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -266,6 +266,10 @@ module ActiveRecord
         @local_tz = execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
       end
 
+      def self.visitor_for(pool) # :nodoc:
+        Arel::Visitors::PostgreSQL.new(pool)
+      end
+
       # Clears the prepared statements cache.
       def clear_cache!
         @statements.each_value do |value|

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,4 +1,6 @@
 require 'active_record/connection_adapters/sqlite_adapter'
+
+gem 'sqlite3', '~> 1.3.4'
 require 'sqlite3'
 
 module ActiveRecord

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -54,6 +54,10 @@ module ActiveRecord
         @config = config
       end
 
+      def self.visitor_for(pool) # :nodoc:
+        Arel::Visitors::SQLite.new(pool)
+      end
+
       def adapter_name #:nodoc:
         'SQLite'
       end
@@ -142,7 +146,7 @@ module ActiveRecord
       end
 
       def quote_column_name(name) #:nodoc:
-        %Q("#{name}")
+        %Q("#{name.to_s.gsub('"', '""')}")
       end
 
       # Quote date/time values for use in SQL input. Includes microseconds

data/lib/active_record/counter_cache.rb

@@ -33,7 +33,7 @@ module ActiveRecord
         stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
           arel_table[counter_name] => object.send(association).count
         })
-        connection.update stmt.to_sql
+        connection.update stmt
       end
       return true
     end

data/lib/active_record/locking/optimistic.rb

@@ -70,7 +70,7 @@ module ActiveRecord
 
           # If the locking column has no default value set,
           # start the lock version at zero. Note we can't use
-          # <tt>locking_enabled?</tt> at this point as 
+          # <tt>locking_enabled?</tt> at this point as
           # <tt>@attributes</tt> may not have been initialized yet.
 
           if result.key?(self.class.locking_column) && lock_optimistically
@@ -100,7 +100,7 @@ module ActiveRecord
               )
             ).arel.compile_update(arel_attributes_values(false, false, attribute_names))
 
-            affected_rows = connection.update stmt.to_sql
+            affected_rows = connection.update stmt
 
             unless affected_rows == 1
               raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"

data/lib/active_record/migration.rb

@@ -332,6 +332,10 @@ module ActiveRecord
       (delegate || superclass.delegate).send(name, *args, &block)
     end
 
+    def self.migrate(direction)
+      new.migrate direction
+    end
+
     cattr_accessor :verbose
 
     attr_accessor :name, :version
@@ -559,7 +563,7 @@ module ActiveRecord
 
       def get_all_versions
         table = Arel::Table.new(schema_migrations_table_name)
-        Base.connection.select_values(table.project(table['version']).to_sql).map{ |v| v.to_i }.sort
+        Base.connection.select_values(table.project(table['version'])).map{ |v| v.to_i }.sort
       end
 
       def current_version
@@ -716,11 +720,11 @@ module ActiveRecord
         if down?
           @migrated_versions.delete(version)
           stmt = table.where(table["version"].eq(version.to_s)).compile_delete
-          Base.connection.delete stmt.to_sql
+          Base.connection.delete stmt
         else
           @migrated_versions.push(version).sort!
           stmt = table.compile_insert table["version"] => version.to_s
-          Base.connection.insert stmt.to_sql
+          Base.connection.insert stmt
         end
       end
 

data/lib/active_record/observer.rb

@@ -111,7 +111,7 @@ module ActiveRecord
           callback_meth = :"_notify_#{observer_name}_for_#{callback}"
           unless klass.respond_to?(callback_meth)
             klass.send(:define_method, callback_meth) do |&block|
-              observer.send(callback, self, &block)
+              observer.update(callback, self, &block)
             end
             klass.send(callback, callback_meth)
           end

data/lib/active_record/persistence.rb

@@ -302,7 +302,7 @@ module ActiveRecord
       return 0 if attributes_with_values.empty?
       klass = self.class
       stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id)).arel.compile_update(attributes_with_values)
-      klass.connection.update stmt.to_sql
+      klass.connection.update stmt
     end
 
     # Creates a record with values matching those of the instance attributes

data/lib/active_record/railties/databases.rake

@@ -341,7 +341,8 @@ db_namespace = namespace :db do
     desc 'Create a db/schema.rb file that can be portably used against any DB supported by AR'
     task :dump => :load_config do
       require 'active_record/schema_dumper'
-      File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
+      filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
+      File.open(filename, "w:utf-8") do |file|
         ActiveRecord::Base.establish_connection(Rails.env)
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end

data/lib/active_record/relation.rb

@@ -68,7 +68,7 @@ module ActiveRecord
       end
 
       conn.insert(
-        im.to_sql,
+        im,
         'SQL',
         primary_key,
         primary_key_value,
@@ -108,10 +108,10 @@ module ActiveRecord
 
       if default_scoped.equal?(self)
         @records = if @readonly_value.nil? && !@klass.locking_enabled?
-          eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql, @bind_values)
+          eager_loading? ? find_with_associations : @klass.find_by_sql(arel, @bind_values)
         else
           IdentityMap.without do
-            eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql, @bind_values)
+            eager_loading? ? find_with_associations : @klass.find_by_sql(arel, @bind_values)
           end
         end
 
@@ -216,15 +216,21 @@ module ActiveRecord
       if conditions || options.present?
         where(conditions).apply_finder_options(options.slice(:limit, :order)).update_all(updates)
       else
-        stmt = arel.compile_update(Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates)))
+        stmt = Arel::UpdateManager.new(arel.engine)
 
-        if limit = arel.limit
-          stmt.take limit
+        stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
+        stmt.table(table)
+        stmt.key = table[primary_key]
+
+        if joins_values.any?
+          @klass.connection.join_to_update(stmt, arel)
+        else
+          stmt.take(arel.limit)
+          stmt.order(*arel.orders)
+          stmt.wheres = arel.constraints
         end
 
-        stmt.order(*arel.orders)
-        stmt.key = table[primary_key]
-        @klass.connection.update stmt.to_sql, 'SQL', bind_values
+        @klass.connection.update stmt, 'SQL', bind_values
       end
     end
 
@@ -342,8 +348,7 @@ module ActiveRecord
         where(conditions).delete_all
       else
         statement = arel.compile_delete
-        affected = @klass.connection.delete(
-          statement.to_sql, 'SQL', bind_values)
+        affected = @klass.connection.delete(statement, 'SQL', bind_values)
 
         reset
         affected
@@ -389,7 +394,7 @@ module ActiveRecord
     end
 
     def to_sql
-      @to_sql ||= arel.to_sql
+      @to_sql ||= klass.connection.to_sql(arel)
     end
 
     def where_values_hash

data/lib/active_record/relation/calculations.rb

@@ -219,7 +219,7 @@ module ActiveRecord
         query_builder = relation.arel
       end
 
-      type_cast_calculated_value(@klass.connection.select_value(query_builder.to_sql), column_for(column_name), operation)
+      type_cast_calculated_value(@klass.connection.select_value(query_builder), column_for(column_name), operation)
     end
 
     def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
@@ -254,7 +254,7 @@ module ActiveRecord
       relation = except(:group).group(group.join(','))
       relation.select_values = select_values
 
-      calculated_data = @klass.connection.select_all(relation.to_sql)
+      calculated_data = @klass.connection.select_all(relation)
 
       if association
         key_ids     = calculated_data.collect { |row| row[group_aliases.first] }

data/lib/active_record/relation/finder_methods.rb

@@ -194,7 +194,7 @@ module ActiveRecord
         relation = relation.where(table[primary_key].eq(id)) if id
       end
 
-      connection.select_value(relation.to_sql) ? true : false
+      connection.select_value(relation) ? true : false
     end
 
     protected
@@ -202,7 +202,7 @@ module ActiveRecord
     def find_with_associations
       join_dependency = construct_join_dependency_for_association_find
       relation = construct_relation_for_association_find(join_dependency)
-      rows = connection.select_all(relation.to_sql, 'SQL', relation.bind_values)
+      rows = connection.select_all(relation, 'SQL', relation.bind_values)
       join_dependency.instantiate(rows)
     rescue ThrowResult
       []

data/lib/active_record/schema_dumper.rb

@@ -40,6 +40,10 @@ module ActiveRecord
       def header(stream)
         define_params = @version ? ":version => #{@version}" : ""
 
+        if stream.respond_to?(:external_encoding)
+          stream.puts "# encoding: #{stream.external_encoding.name}"
+        end
+
         stream.puts <<HEADER
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to

data/lib/active_record/validations/associated.rb

@@ -17,15 +17,7 @@ module ActiveRecord
       #     validates_associated :pages, :library
       #   end
       #
-      # Warning: If, after the above definition, you then wrote:
-      #
-      #   class Page < ActiveRecord::Base
-      #     belongs_to :book
-      #
-      #     validates_associated :book
-      #   end
-      #
-      # this would specify a circular dependency and cause infinite recursion.
+      # WARNING: This validation must not be used on both ends of an association. Doing so will lead to a circular dependency and cause infinite recursion.
       #
       # NOTE: This validation will not fail if the association hasn't been assigned. If you want to
       # ensure that the association is both present and guaranteed to be valid, you also need to

data/lib/active_record/version.rb

@@ -3,7 +3,7 @@ module ActiveRecord
     MAJOR = 3
     MINOR = 1
     TINY  = 0
-    PRE   = "rc5"
+    PRE   = "rc6"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord
 version: !ruby/object:Gem::Version 
-  prerelease: true
+  hash: 15424105
+  prerelease: 6
   segments: 
   - 3
   - 1
   - 0
-  - rc5
-  version: 3.1.0.rc5
+  - rc
+  - 6
+  version: 3.1.0.rc6
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -15,60 +17,69 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-25 00:00:00 -07:00
-default_executable: 
+date: 2011-08-16 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
+        hash: 15424105
         segments: 
         - 3
         - 1
         - 0
-        - rc5
-        version: 3.1.0.rc5
+        - rc
+        - 6
+        version: 3.1.0.rc6
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: activemodel
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
+        hash: 15424105
         segments: 
         - 3
         - 1
         - 0
-        - rc5
-        version: 3.1.0.rc5
+        - rc
+        - 6
+        version: 3.1.0.rc6
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: arel
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 5
         segments: 
         - 2
+        - 2
         - 1
-        - 4
-        version: 2.1.4
+        version: 2.2.1
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: tzinfo
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 41
         segments: 
         - 0
         - 3
@@ -212,7 +223,6 @@ files:
 - lib/rails/generators/active_record/session_migration/session_migration_generator.rb
 - lib/rails/generators/active_record/session_migration/templates/migration.rb
 - lib/rails/generators/active_record.rb
-has_rdoc: true
 homepage: http://www.rubyonrails.org
 licenses: []
 
@@ -223,18 +233,22 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 57
       segments: 
       - 1
       - 8
       - 7
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">"
     - !ruby/object:Gem::Version 
+      hash: 25
       segments: 
       - 1
       - 3
@@ -243,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: Object-relational mapper framework (part of Rails).