From ee31847a5a650c93a49ebb6e4d1dc93bd2c1923f Mon Sep 17 00:00:00 2001
From: Evgeniy Dolzhenko <dolzenko@gmail.com>
Date: Fri, 1 Oct 2010 14:26:17 +0400
Subject: Fix serialization :include option name

---
 activerecord/lib/active_record/serialization.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb
index ad3f7afd6f..dc73075a59 100644
--- a/activerecord/lib/active_record/serialization.rb
+++ b/activerecord/lib/active_record/serialization.rb
@@ -22,7 +22,7 @@ module ActiveRecord #:nodoc:
     end
 
     private
-      # Add associations specified via the <tt>:includes</tt> option.
+      # Add associations specified via the <tt>:include</tt> option.
       #
       # Expects a block that takes as arguments:
       #   +association+ - name of the association
-- 
cgit v1.2.3


From d649bf158be130515566aed987f83d36ac9b0ae8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Valim?= <jose.valim@gmail.com>
Date: Wed, 6 Oct 2010 17:18:59 +0200
Subject: Provide a cleaner syntax for paths configuration that does not rely
 on method_missing.

---
 activerecord/lib/active_record/railties/databases.rake | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 58c705c8b2..4ef6c6f751 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -2,7 +2,7 @@ namespace :db do
   task :load_config => :rails_env do
     require 'active_record'
     ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-    ActiveRecord::Migrator.migrations_path = Rails.application.config.paths.db.migrate.to_a.first
+    ActiveRecord::Migrator.migrations_path = Rails.application.paths["db/migrate"].first
   end
 
   task :copy_migrations => :load_config do
@@ -11,8 +11,8 @@ namespace :db do
     Rails.application.railties.all do |railtie|
       next unless to_load == :all || to_load.include?(railtie.railtie_name)
 
-      if railtie.config.respond_to?(:paths) && railtie.config.paths.db
-        railties[railtie.railtie_name] = railtie.config.paths.db.migrate.to_a.first
+      if railtie.respond_to?(:paths) && (path = railtie.paths["db/migrate"].first)
+        railties[railtie.railtie_name] = path
       end
     end
 
-- 
cgit v1.2.3


From 2a04110f266b6ccaf94aeeae224af578a9620fbd Mon Sep 17 00:00:00 2001
From: Hemant Kumar <hkumar@crri.co.in>
Date: Thu, 30 Sep 2010 12:12:23 +0530
Subject: fix ruby 1.9 deadlock problem, fixes #5736 add connection pool tests

---
 .../connection_adapters/abstract/connection_pool.rb        | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 37e584a629..0c264de869 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -75,10 +75,7 @@ module ActiveRecord
         @queue = @connection_mutex.new_cond
 
         # default 5 second timeout unless on ruby 1.9
-        @timeout =
-          if RUBY_VERSION < '1.9'
-            spec.config[:wait_timeout] || 5
-          end
+        @timeout = spec.config[:wait_timeout] || 5
 
         # default max pool size to 5
         @size = (spec.config[:pool] && spec.config[:pool].to_i) || 5
@@ -161,7 +158,6 @@ module ActiveRecord
         keys = @reserved_connections.keys - Thread.list.find_all { |t|
           t.alive?
         }.map { |thread| thread.object_id }
-
         keys.each do |key|
           checkin @reserved_connections[key]
           @reserved_connections.delete(key)
@@ -194,16 +190,18 @@ module ActiveRecord
                      checkout_new_connection
                    end
             return conn if conn
-            # No connections available; wait for one
-            if @queue.wait(@timeout)
+
+            @queue.wait(@timeout)
+
+            if(@checked_out.size < @connections.size)
               next
             else
-              # try looting dead threads
               clear_stale_cached_connections!
               if @size == @checked_out.size
                 raise ConnectionTimeoutError, "could not obtain a database connection#{" within #{@timeout} seconds" if @timeout}.  The max pool size is currently #{@size}; consider increasing it."
               end
             end
+
           end
         end
       end
-- 
cgit v1.2.3


From 740d7e5aa2e778cd3cf87090745b37ee97dac618 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Thu, 7 Oct 2010 16:40:15 -0600
Subject: removing false comment

---
 .../lib/active_record/connection_adapters/abstract/connection_pool.rb   | 2 --
 1 file changed, 2 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 0c264de869..ca9314ec99 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -73,8 +73,6 @@ module ActiveRecord
         # The mutex used to synchronize pool access
         @connection_mutex = Monitor.new
         @queue = @connection_mutex.new_cond
-
-        # default 5 second timeout unless on ruby 1.9
         @timeout = spec.config[:wait_timeout] || 5
 
         # default max pool size to 5
-- 
cgit v1.2.3


From 4377f8eba2dde51fe5d3bc50248c0089e24c8d24 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Fri, 8 Oct 2010 21:17:14 +0200
Subject: Change the method for copying migrations, do not add scope.

The purpose of this change is to allow copying fail on the same names.
Migrations change database and they should be treated with caution,
if 2 migrations are named the same it's much better to skip migration
and allow user decide if it should be copied or not.
---
 activerecord/lib/active_record/migration.rb | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index 9ac18f9939..3fc69d7af0 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -387,18 +387,18 @@ module ActiveRecord
       def copy(destination, sources)
         copied = []
 
-        sources.each do |scope, path|
+        sources.each do |name, path|
           destination_migrations = ActiveRecord::Migrator.migrations(destination)
           source_migrations = ActiveRecord::Migrator.migrations(path)
           last = destination_migrations.last
 
           source_migrations.each do |migration|
-            next if destination_migrations.any? { |m| m.name == migration.name && m.scope == scope.to_s }
+            next if destination_migrations.any? { |m| m.name == migration.name }
 
             migration.version = next_migration_number(last ? last.version + 1 : 0).to_i
             last = migration
 
-            new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.#{scope}.rb")
+            new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.rb")
             FileUtils.cp(migration.filename, new_path)
             copied << new_path
           end
@@ -419,9 +419,9 @@ module ActiveRecord
 
   # MigrationProxy is used to defer loading of the actual migration classes
   # until they are needed
-  class MigrationProxy < Struct.new(:name, :version, :filename, :scope)
+  class MigrationProxy < Struct.new(:name, :version, :filename)
 
-    def initialize(name, version, filename, scope)
+    def initialize(name, version, filename)
       super
       @migration = nil
     end
@@ -510,18 +510,18 @@ module ActiveRecord
         seen = Hash.new false
 
         migrations = files.map do |file|
-          version, name, scope = file.scan(/([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?.rb/).first
+          version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
 
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
           name = name.camelize
 
           raise DuplicateMigrationVersionError.new(version) if seen[version]
-          raise DuplicateMigrationNameError.new(name) if seen[[name, scope]]
+          raise DuplicateMigrationNameError.new(name) if seen[name]
 
-          seen[version] = seen[[name, scope]] = true
+          seen[version] = seen[name] = true
 
-          MigrationProxy.new(name, version, file, scope)
+          MigrationProxy.new(name, version, file)
         end
 
         migrations.sort_by(&:version)
-- 
cgit v1.2.3


From 022205be1d677d446437af0618697434472157e8 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Sat, 9 Oct 2010 10:28:46 +0200
Subject: Add callback on skipped migration while copying migrations

---
 activerecord/lib/active_record/migration.rb | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index 3fc69d7af0..a4c09b654a 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -384,23 +384,32 @@ module ActiveRecord
         end
       end
 
-      def copy(destination, sources)
+      def copy(destination, sources, options = {})
         copied = []
 
+        destination_migrations = ActiveRecord::Migrator.migrations(destination)
+        last = destination_migrations.last
         sources.each do |name, path|
-          destination_migrations = ActiveRecord::Migrator.migrations(destination)
           source_migrations = ActiveRecord::Migrator.migrations(path)
-          last = destination_migrations.last
 
           source_migrations.each do |migration|
-            next if destination_migrations.any? { |m| m.name == migration.name }
+            source = File.read(migration.filename)
+            source = "# This migration comes from #{name} (originally #{migration.version})\n#{source}"
+
+            if duplicate = destination_migrations.detect { |m| m.name == migration.name }
+              options[:on_skip].call(name, migration) if File.read(duplicate.filename) != source && options[:on_skip]
+              next
+            end
 
             migration.version = next_migration_number(last ? last.version + 1 : 0).to_i
+            new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.rb")
+            old_path, migration.filename = migration.filename, new_path
             last = migration
 
-            new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.rb")
-            FileUtils.cp(migration.filename, new_path)
-            copied << new_path
+            FileUtils.cp(old_path, migration.filename)
+            copied << migration
+            options[:on_copy].call(name, migration, old_path) if options[:on_copy]
+            destination_migrations << migration
           end
         end
 
@@ -426,6 +435,10 @@ module ActiveRecord
       @migration = nil
     end
 
+    def basename
+      File.basename(filename)
+    end
+
     delegate :migrate, :announce, :write, :to=>:migration
 
     private
-- 
cgit v1.2.3


From 8636f64defb4b6fd9f00c70ffc9dc7ffc017fe58 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Sat, 9 Oct 2010 12:15:36 +0200
Subject: Rename rake railties:copy_migrations to rake
 railties:install:migrations and fix it to work with new copying strategy

---
 .../lib/active_record/railties/databases.rake      | 48 +++++++++++-----------
 1 file changed, 25 insertions(+), 23 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 4ef6c6f751..778bce697e 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -5,27 +5,6 @@ namespace :db do
     ActiveRecord::Migrator.migrations_path = Rails.application.paths["db/migrate"].first
   end
 
-  task :copy_migrations => :load_config do
-    to_load = ENV["FROM"].blank? ? :all : ENV["FROM"].split(",").map {|n| n.strip }
-    railties = {}
-    Rails.application.railties.all do |railtie|
-      next unless to_load == :all || to_load.include?(railtie.railtie_name)
-
-      if railtie.respond_to?(:paths) && (path = railtie.paths["db/migrate"].first)
-        railties[railtie.railtie_name] = path
-      end
-    end
-
-    copied = ActiveRecord::Migration.copy(ActiveRecord::Migrator.migrations_path, railties)
-
-    if copied.blank?
-      puts "No migrations were copied, project is up to date."
-    else
-      puts "The following migrations were copied:"
-      puts copied.map{ |path| File.basename(path) }.join("\n")
-    end
-  end
-
   namespace :create do
     # desc 'Create all the local databases defined in config/database.yml'
     task :all => :load_config do
@@ -501,8 +480,31 @@ namespace :db do
 end
 
 namespace :railties do
-  desc "Copies missing migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
-  task :copy_migrations => 'db:copy_migrations'
+  namespace :install do
+    desc "Copies missing migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
+    task :migrations => :"db:load_config" do
+      to_load = ENV["FROM"].blank? ? :all : ENV["FROM"].split(",").map {|n| n.strip }
+      railties = {}
+      Rails.application.railties.all do |railtie|
+        next unless to_load == :all || to_load.include?(railtie.railtie_name)
+
+        if railtie.respond_to?(:paths) && (path = railtie.paths["db/migrate"].first)
+          railties[railtie.railtie_name] = path
+        end
+      end
+
+      on_skip = Proc.new do |name, migration|
+        $stderr.puts "WARNING: Migration #{migration.basename} from #{name} has been skipped. Migration with the same name already exists."
+      end
+
+      on_copy = Proc.new do |name, migration, old_path|
+        puts "Copied migration #{migration.basename} from #{name}"
+      end
+
+      ActiveRecord::Migration.copy( ActiveRecord::Migrator.migrations_path, railties,
+                                    :on_skip => on_skip, :on_copy => on_copy)
+    end
+  end
 end
 
 task 'test:prepare' => 'db:test:prepare'
-- 
cgit v1.2.3


From a8b1780410a86be58ac0f341ae6b079800783fcf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Valim?= <jose.valim@gmail.com>
Date: Mon, 11 Oct 2010 10:29:31 +0200
Subject: Updated DOCS for engines and added a couple TODOs. Also, commented
 internal railties rake tasks description.

---
 activerecord/lib/active_record/railties/databases.rake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 778bce697e..5ad440e58d 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -481,7 +481,7 @@ end
 
 namespace :railties do
   namespace :install do
-    desc "Copies missing migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
+    # desc "Copies missing migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
     task :migrations => :"db:load_config" do
       to_load = ENV["FROM"].blank? ? :all : ENV["FROM"].split(",").map {|n| n.strip }
       railties = {}
-- 
cgit v1.2.3


From e0b76d6151821527f16b3f163abde3ebea1b2a50 Mon Sep 17 00:00:00 2001
From: Santiago Pastorino <santiago@wyeworks.com>
Date: Sun, 10 Oct 2010 21:32:01 -0200
Subject: reorder removed in favor of except(:order).order

---
 activerecord/lib/active_record/base.rb                   |  2 +-
 activerecord/lib/active_record/relation/query_methods.rb | 11 +----------
 activerecord/lib/active_record/relation/spawn_methods.rb | 11 +----------
 3 files changed, 3 insertions(+), 21 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index ff6be4ff19..78b3507dd9 100644
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -423,7 +423,7 @@ module ActiveRecord #:nodoc:
     class << self # Class methods
       delegate :find, :first, :last, :all, :destroy, :destroy_all, :exists?, :delete, :delete_all, :update, :update_all, :to => :scoped
       delegate :find_each, :find_in_batches, :to => :scoped
-      delegate :select, :group, :order, :reorder, :limit, :offset, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
+      delegate :select, :group, :order, :except, :limit, :offset, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
       delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped
 
       # Executes a custom SQL query against your database and returns all the results.  The results will
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index 001207514d..a5dc051c6e 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -6,7 +6,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     attr_accessor :includes_values, :eager_load_values, :preload_values,
-                  :select_values, :group_values, :order_values, :reorder_flag, :joins_values, :where_values, :having_values,
+                  :select_values, :group_values, :order_values, :joins_values, :where_values, :having_values,
                   :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value
 
     def includes(*args)
@@ -53,15 +53,6 @@ module ActiveRecord
       relation
     end
 
-    def reorder(*args)
-      relation = clone
-      unless args.blank?
-        relation.order_values = args
-        relation.reorder_flag = true
-      end
-      relation
-    end
-
     def joins(*args)
       relation = clone
 
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index 9ecdb99bee..dcddc3dac4 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -19,20 +19,11 @@ module ActiveRecord
         end
       end
 
-      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order]).each do |method|
+      (Relation::MULTI_VALUE_METHODS - [:joins, :where]).each do |method|
         value = r.send(:"#{method}_values")
         merged_relation.send(:"#{method}_values=", merged_relation.send(:"#{method}_values") + value) if value.present?
       end
 
-      order_value = r.order_values
-      if order_value.present?
-        if r.reorder_flag
-          merged_relation.order_values = order_value
-        else
-          merged_relation.order_values = merged_relation.order_values + order_value
-        end
-      end
-
       merged_relation = merged_relation.joins(r.joins_values)
 
       merged_wheres = @where_values
-- 
cgit v1.2.3


From 1c9022de212c190362d40b98624dcf71d20ca073 Mon Sep 17 00:00:00 2001
From: Marcelo Giorgi <marklazz.uy@gmail.com>
Date: Fri, 1 Oct 2010 08:27:02 -0300
Subject: Honor distinct option when used with count operation after group
 clause [#5721 state:resolved]

---
 activerecord/lib/active_record/relation/calculations.rb | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index d79ef78b4d..3519880335 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -177,7 +177,7 @@ module ActiveRecord
       distinct = options[:distinct] || distinct
 
       if @group_values.any?
-        execute_grouped_calculation(operation, column_name)
+        execute_grouped_calculation(operation, column_name, distinct)
       else
         execute_simple_calculation(operation, column_name, distinct)
       end
@@ -191,19 +191,23 @@ module ActiveRecord
       end
     end
 
+    def operation_over_aggregate_column(column, operation, distinct)
+      operation == 'count' ? column.count(distinct) : column.send(operation)
+    end
+
     def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
       column = aggregate_column(column_name)
 
       # Postgresql doesn't like ORDER BY when there are no GROUP BY
       relation = except(:order)
-      select_value = operation == 'count' ? column.count(distinct) : column.send(operation)
+      select_value = operation_over_aggregate_column(column, operation, distinct)
 
       relation.select_values = [select_value]
 
       type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
     end
 
-    def execute_grouped_calculation(operation, column_name) #:nodoc:
+    def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
       group_attr      = @group_values.first
       association     = @klass.reflect_on_association(group_attr.to_sym)
       associated      = association && association.macro == :belongs_to # only count belongs_to associations
@@ -221,7 +225,7 @@ module ActiveRecord
 
       relation = except(:group).group(group)
       relation.select_values = [
-        aggregate_column(column_name).send(operation).as(aggregate_alias),
+        operation_over_aggregate_column(aggregate_column(column_name), operation, distinct).as(aggregate_alias),
         "#{group_field} AS #{group_alias}"
       ]
 
-- 
cgit v1.2.3


From bef5b826e3cc111701ab09000fd4e8e1842a8590 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Mon, 11 Oct 2010 13:02:36 -0700
Subject: removing freeze

---
 activerecord/lib/active_record/connection_adapters/mysql_adapter.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index e7f7b37b27..a4b336dfaf 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -132,7 +132,7 @@ module ActiveRecord
       cattr_accessor :emulate_booleans
       self.emulate_booleans = true
 
-      ADAPTER_NAME = 'MySQL'.freeze
+      ADAPTER_NAME = 'MySQL'
 
       LOST_CONNECTION_ERROR_MESSAGES = [
         "Server shutdown in progress",
@@ -140,10 +140,10 @@ module ActiveRecord
         "Lost connection to MySQL server during query",
         "MySQL server has gone away" ]
 
-      QUOTED_TRUE, QUOTED_FALSE = '1'.freeze, '0'.freeze
+      QUOTED_TRUE, QUOTED_FALSE = '1', '0'
 
       NATIVE_DATABASE_TYPES = {
-        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY".freeze,
+        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
         :string      => { :name => "varchar", :limit => 255 },
         :text        => { :name => "text" },
         :integer     => { :name => "int", :limit => 4 },
-- 
cgit v1.2.3


From cecccf11562f173eb504ac8b7600397d1d3deeb7 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Mon, 11 Oct 2010 13:35:58 -0700
Subject: we should always cast the value based on the column

---
 activerecord/lib/active_record/relation/calculations.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 3519880335..6bf698fe97 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -277,7 +277,7 @@ module ActiveRecord
           else type_cast_using_column(value, column)
         end
       else
-        value
+        type_cast_using_column(value, column)
       end
     end
 
-- 
cgit v1.2.3


From ef11ce2af85cb2171343ba1685fc5483929286bd Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 11:38:40 -0700
Subject: fixing case / when indentation

---
 .../connection_adapters/abstract/quoting.rb        | 40 +++++++++++-----------
 1 file changed, 20 insertions(+), 20 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index e2b3773a99..9967da6b56 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -10,28 +10,28 @@ module ActiveRecord
         return value.quoted_id if value.respond_to?(:quoted_id)
 
         case value
-          when String, ActiveSupport::Multibyte::Chars
-            value = value.to_s
-            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-              "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
-            elsif column && [:integer, :float].include?(column.type)
-              value = column.type == :integer ? value.to_i : value.to_f
-              value.to_s
-            else
-              "'#{quote_string(value)}'" # ' (for ruby-mode)
-            end
-          when NilClass                 then "NULL"
-          when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
-          when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
-          when Float, Fixnum, Bignum    then value.to_s
+        when String, ActiveSupport::Multibyte::Chars
+          value = value.to_s
+          if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+            "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+          elsif column && [:integer, :float].include?(column.type)
+            value = column.type == :integer ? value.to_i : value.to_f
+            value.to_s
+          else
+            "'#{quote_string(value)}'" # ' (for ruby-mode)
+          end
+        when NilClass                 then "NULL"
+        when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
+        when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
+        when Float, Fixnum, Bignum    then value.to_s
           # BigDecimals need to be output in a non-normalized form and quoted.
-          when BigDecimal               then value.to_s('F')
+        when BigDecimal               then value.to_s('F')
+        else
+          if value.acts_like?(:date) || value.acts_like?(:time)
+            "'#{quoted_date(value)}'"
           else
-            if value.acts_like?(:date) || value.acts_like?(:time)
-              "'#{quoted_date(value)}'"
-            else
-              "'#{quote_string(value.to_s)}'"
-            end
+            "'#{quote_string(value.to_s)}'"
+          end
         end
       end
 
-- 
cgit v1.2.3


From 31b132aa9b16bb66446839af888fdff4bad86bcf Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 11:41:23 -0700
Subject: refactoring date / time / datetime when statement

---
 .../connection_adapters/abstract/quoting.rb           | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 9967da6b56..39bd5e1cab 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -20,18 +20,15 @@ module ActiveRecord
           else
             "'#{quote_string(value)}'" # ' (for ruby-mode)
           end
-        when NilClass                 then "NULL"
-        when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
-        when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
-        when Float, Fixnum, Bignum    then value.to_s
-          # BigDecimals need to be output in a non-normalized form and quoted.
-        when BigDecimal               then value.to_s('F')
+        when NilClass              then "NULL"
+        when TrueClass             then (column && column.type == :integer ? '1' : quoted_true)
+        when FalseClass            then (column && column.type == :integer ? '0' : quoted_false)
+        when Float, Fixnum, Bignum then value.to_s
+          # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal            then value.to_s('F')
+        when Date, Time, DateTime  then "'#{quoted_date(value)}'"
         else
-          if value.acts_like?(:date) || value.acts_like?(:time)
-            "'#{quoted_date(value)}'"
-          else
-            "'#{quote_string(value.to_s)}'"
-          end
+          "'#{quote_string(value.to_s)}'"
         end
       end
 
-- 
cgit v1.2.3


From c882154cd121ea494019afa0c9ce8d31767de691 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 11:45:59 -0700
Subject: reduce the number of times we test for the column variable

---
 .../lib/active_record/connection_adapters/abstract/quoting.rb      | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 39bd5e1cab..820c6d9f0c 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -12,14 +12,17 @@ module ActiveRecord
         case value
         when String, ActiveSupport::Multibyte::Chars
           value = value.to_s
-          if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+          return "'#{quote_string(value)}'" unless column
+
+          if column.type == :binary && column.class.respond_to?(:string_to_binary)
             "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
-          elsif column && [:integer, :float].include?(column.type)
+          elsif [:integer, :float].include?(column.type)
             value = column.type == :integer ? value.to_i : value.to_f
             value.to_s
           else
             "'#{quote_string(value)}'" # ' (for ruby-mode)
           end
+
         when NilClass              then "NULL"
         when TrueClass             then (column && column.type == :integer ? '1' : quoted_true)
         when FalseClass            then (column && column.type == :integer ? '0' : quoted_false)
-- 
cgit v1.2.3


From 9852a724177cb5f65d5b37c0511cfacea2a3ebb6 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 11:48:41 -0700
Subject: removing intermediate variables

---
 activerecord/lib/active_record/connection_adapters/abstract/quoting.rb | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 820c6d9f0c..603e4de564 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -17,8 +17,7 @@ module ActiveRecord
           if column.type == :binary && column.class.respond_to?(:string_to_binary)
             "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
           elsif [:integer, :float].include?(column.type)
-            value = column.type == :integer ? value.to_i : value.to_f
-            value.to_s
+            (column.type == :integer ? value.to_i : value.to_f).to_s
           else
             "'#{quote_string(value)}'" # ' (for ruby-mode)
           end
-- 
cgit v1.2.3


From 01893f43f68f3cba24751022131d51702d188979 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 11:55:52 -0700
Subject: reducing comparisons in when statements

---
 .../active_record/connection_adapters/abstract/quoting.rb    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 603e4de564..b28eb3f758 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -22,13 +22,13 @@ module ActiveRecord
             "'#{quote_string(value)}'" # ' (for ruby-mode)
           end
 
-        when NilClass              then "NULL"
-        when TrueClass             then (column && column.type == :integer ? '1' : quoted_true)
-        when FalseClass            then (column && column.type == :integer ? '0' : quoted_false)
-        when Float, Fixnum, Bignum then value.to_s
+        when nil        then "NULL"
+        when true       then (column && column.type == :integer ? '1' : quoted_true)
+        when false      then (column && column.type == :integer ? '0' : quoted_false)
           # BigDecimals need to be put in a non-normalized form and quoted.
-        when BigDecimal            then value.to_s('F')
-        when Date, Time, DateTime  then "'#{quoted_date(value)}'"
+        when BigDecimal then value.to_s('F')
+        when Numeric    then value.to_s
+        when Date, Time then "'#{quoted_date(value)}'"
         else
           "'#{quote_string(value.to_s)}'"
         end
-- 
cgit v1.2.3


From 5b5ae01f294c2a305c62372be732cc59f97d3c06 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 11:59:20 -0700
Subject: drying up true and false cases

---
 .../lib/active_record/connection_adapters/abstract/quoting.rb  | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index b28eb3f758..1e0c5fe902 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -22,10 +22,14 @@ module ActiveRecord
             "'#{quote_string(value)}'" # ' (for ruby-mode)
           end
 
-        when nil        then "NULL"
-        when true       then (column && column.type == :integer ? '1' : quoted_true)
-        when false      then (column && column.type == :integer ? '0' : quoted_false)
+        when true, false
+          if column && column.type == :integer
+            value ? '1' : '0'
+          else
+            value ? quoted_true : quoted_false
+          end
           # BigDecimals need to be put in a non-normalized form and quoted.
+        when nil        then "NULL"
         when BigDecimal then value.to_s('F')
         when Numeric    then value.to_s
         when Date, Time then "'#{quoted_date(value)}'"
-- 
cgit v1.2.3


From 4b2e16ed248d294133b8c5212f5facac78625e42 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 13:10:52 -0700
Subject: all columns respond to string_to_binary, so no need to check
 respond_to?

---
 .../lib/active_record/connection_adapters/abstract/quoting.rb    | 4 ++--
 .../connection_adapters/abstract/schema_definitions.rb           | 9 +++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 1e0c5fe902..a3928b4504 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -14,8 +14,8 @@ module ActiveRecord
           value = value.to_s
           return "'#{quote_string(value)}'" unless column
 
-          if column.type == :binary && column.class.respond_to?(:string_to_binary)
-            "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+          if column.type == :binary
+            "'#{quote_string(column.string_to_binary(value))}'" # ' (for ruby-mode)
           elsif [:integer, :float].include?(column.type)
             (column.type == :integer ? value.to_i : value.to_f).to_s
           else
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index 6480aeb171..60ccf9edf3 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -114,6 +114,11 @@ module ActiveRecord
         type_cast(default)
       end
 
+      # Used to convert from Strings to BLOBs
+      def string_to_binary(value)
+        self.class.string_to_binary(value)
+      end
+
       class << self
         # Used to convert from Strings to BLOBs
         def string_to_binary(value)
@@ -268,6 +273,10 @@ module ActiveRecord
     # for generating a number of table creation or table changing SQL statements.
     class ColumnDefinition < Struct.new(:base, :name, :type, :limit, :precision, :scale, :default, :null) #:nodoc:
 
+      def string_to_binary(value)
+        value
+      end
+
       def sql_type
         base.type_to_sql(type.to_sym, limit, precision, scale) rescue type
       end
-- 
cgit v1.2.3


From 25a2909355891fc3cbe3f5036191131e9d301580 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 13:13:19 -0700
Subject: dry up column type testing

---
 .../lib/active_record/connection_adapters/abstract/quoting.rb  | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index a3928b4504..a7a12faac2 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -14,12 +14,12 @@ module ActiveRecord
           value = value.to_s
           return "'#{quote_string(value)}'" unless column
 
-          if column.type == :binary
-            "'#{quote_string(column.string_to_binary(value))}'" # ' (for ruby-mode)
-          elsif [:integer, :float].include?(column.type)
-            (column.type == :integer ? value.to_i : value.to_f).to_s
+          case column.type
+          when :binary then "'#{quote_string(column.string_to_binary(value))}'"
+          when :integer then value.to_i.to_s
+          when :float then value.to_f.to_s
           else
-            "'#{quote_string(value)}'" # ' (for ruby-mode)
+            "'#{quote_string(value)}'"
           end
 
         when true, false
-- 
cgit v1.2.3


From 603406dc53b656f7f317fe2ac6c4bac616a86368 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 12 Oct 2010 14:32:14 -0700
Subject: stop using deprecated arel API

---
 activerecord/lib/active_record/relation/finder_methods.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index ede1c8821e..e950dce62b 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -291,8 +291,8 @@ module ActiveRecord
       record = where(primary_key.eq(id)).first
 
       unless record
-        conditions = arel.wheres.map { |x| x.value }.join(', ')
-        conditions = " [WHERE #{conditions}]" if conditions.present?
+        conditions = arel.where_sql
+        conditions = " [#{conditions}]" if conditions
         raise RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}#{conditions}"
       end
 
-- 
cgit v1.2.3


From 7dcb6334271aaecf53cbe99fe6f354a351bde210 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Wed, 13 Oct 2010 12:10:51 +0100
Subject: Refactor JoinDependency and friends so that a JoinAssociation can
 produce an arbitrary number of joins, which will be needed in order to
 support nested through associations.

---
 activerecord/lib/active_record/associations.rb     | 410 +++++++++++++--------
 .../lib/active_record/relation/query_methods.rb    |  13 +-
 2 files changed, 266 insertions(+), 157 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 565ebf8197..bf13898e92 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -1924,7 +1924,9 @@ module ActiveRecord
                   reflection = parent.reflections[associations.to_s.intern] or
                   raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
                   @reflections << reflection
-                  @joins << build_join_association(reflection, parent).with_join_class(join_class)
+                  join_association = build_join_association(reflection, parent)
+                  join_association.join_class = join_class
+                  @joins << join_association
                 when Array
                   associations.each do |association|
                     build(association, parent, join_class)
@@ -2005,35 +2007,51 @@ module ActiveRecord
               association_proxy = record.send("set_#{join.reflection.name}_target", association)
               association_proxy.__send__(:set_inverse_instance, association, record)
             end
-
-          class JoinBase # :nodoc:
-            attr_reader :active_record, :table_joins
-            delegate    :table_name, :column_names, :primary_key, :reflections, :sanitize_sql, :arel_engine, :to => :active_record
-
-            def initialize(active_record, joins = nil)
+          
+          # A JoinPart represents a part of a JoinDependency. It is an abstract class, inherited
+          # by JoinBase and JoinAssociation. A JoinBase represents the Active Record which 
+          # everything else is being joined onto. A JoinAssociation represents an association which
+          # is joining to the base. A JoinAssociation may result in more than one actual join
+          # operations (for example a has_and_belongs_to_many JoinAssociation would result in
+          # two; one for the join table and one for the target table).
+          class JoinPart # :nodoc:
+            # The Active Record class which this join part is associated 'about'; for a JoinBase
+            # this is the actual base model, for a JoinAssociation this is the target model of the
+            # association.
+            attr_reader :active_record
+            
+            delegate :table_name, :column_names, :primary_key, :reflections, :sanitize_sql, :arel_engine, :to => :active_record
+            
+            def initialize(active_record)
               @active_record = active_record
               @cached_record = {}
-              @table_joins   = joins
             end
-
+            
             def ==(other)
-              other.class == self.class &&
-              other.active_record == active_record &&
-              other.table_joins == table_joins
+              raise NotImplementedError
             end
-
+            
+            # An Arel::Table for the active_record
+            def table
+              raise NotImplementedError
+            end
+            
+            # The prefix to be used when aliasing columns in the active_record's table
             def aliased_prefix
-              "t0"
+              raise NotImplementedError
             end
-
+            
+            # The alias for the active_record's table
+            def aliased_table_name
+              raise NotImplementedError
+            end
+            
+            # The alias for the primary key of the active_record's table
             def aliased_primary_key
               "#{aliased_prefix}_r0"
             end
-
-            def aliased_table_name
-              active_record.table_name
-            end
-
+            
+            # An array of [column_name, alias] pairs for the table
             def column_names_with_alias
               unless defined?(@column_names_with_alias)
                 @column_names_with_alias = []
@@ -2059,33 +2077,74 @@ module ActiveRecord
             end
           end
 
-          class JoinAssociation < JoinBase # :nodoc:
-            attr_reader :reflection, :parent, :aliased_table_name, :aliased_prefix, :aliased_join_table_name, :parent_table_name, :join_class
-            delegate    :options, :klass, :through_reflection, :source_reflection, :to => :reflection
+          class JoinBase < JoinPart # :nodoc:
+            # Extra joins provided when the JoinDependency was created
+            attr_reader :table_joins
+            
+            def initialize(active_record, joins = nil)
+              super(active_record)
+              @table_joins = joins
+            end
+
+            def ==(other)
+              other.class == self.class &&
+              other.active_record == active_record &&
+              other.table_joins == table_joins
+            end
+
+            def aliased_prefix
+              "t0"
+            end
+
+            def table
+              Arel::Table.new(table_name, :engine => arel_engine, :columns => active_record.columns)
+            end
+
+            def aliased_table_name
+              active_record.table_name
+            end
+          end
+
+          class JoinAssociation < JoinPart # :nodoc:
+            # The reflection of the association represented
+            attr_reader :reflection
+            
+            # The JoinDependency object which this JoinAssociation exists within. This is mainly
+            # relevant for generating aliases which do not conflict with other joins which are 
+            # part of the query.
+            attr_reader :join_dependency
+            
+            # A JoinBase instance representing the active record we are joining onto.
+            # (So in Author.has_many :posts, the Author would be that base record.)
+            attr_reader :parent
+            
+            # What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
+            attr_accessor :join_class
+            
+            # These implement abstract methods from the superclass
+            attr_reader :aliased_prefix, :aliased_table_name
+            
+            delegate :options, :through_reflection, :source_reflection, :to => :reflection
+            delegate :table, :table_name, :to => :parent, :prefix => true
 
             def initialize(reflection, join_dependency, parent = nil)
               reflection.check_validity!
+              
               if reflection.options[:polymorphic]
                 raise EagerLoadPolymorphicError.new(reflection)
               end
 
               super(reflection.klass)
-              @join_dependency    = join_dependency
-              @parent             = parent
-              @reflection         = reflection
-              @aliased_prefix     = "t#{ join_dependency.joins.size }"
-              @parent_table_name  = parent.active_record.table_name
-              @aliased_table_name = aliased_table_name_for(table_name)
-              @join               = nil
-              @join_class         = Arel::InnerJoin
-
-              if reflection.macro == :has_and_belongs_to_many
-                @aliased_join_table_name = aliased_table_name_for(reflection.options[:join_table], "_join")
-              end
-
-              if [:has_many, :has_one].include?(reflection.macro) && reflection.options[:through]
-                @aliased_join_table_name = aliased_table_name_for(reflection.through_reflection.klass.table_name, "_join")
-              end
+              
+              @reflection      = reflection
+              @join_dependency = join_dependency
+              @parent          = parent
+              @join_class       = Arel::InnerJoin
+              
+              # This must be done eagerly upon initialisation because the alias which is produced
+              # depends on the state of the join dependency, but we want it to work the same way
+              # every time.
+              allocate_aliases
             end
 
             def ==(other)
@@ -2099,59 +2158,25 @@ module ActiveRecord
                 self.parent == join
               end
             end
-
-            def with_join_class(join_class)
-              @join_class = join_class
-              self
+            
+            def join_to(relation)
+              send("join_#{reflection.macro}_to", relation)
             end
 
-            def association_join
-              return @join if @join
-
-              aliased_table = Arel::Table.new(table_name, :as      => @aliased_table_name,
-                                                          :engine  => arel_engine,
-                                                          :columns => klass.columns)
-
-              parent_table = Arel::Table.new(parent.table_name, :as      => parent.aliased_table_name,
-                                                                :engine  => arel_engine,
-                                                                :columns => parent.active_record.columns)
-
-              @join = send("build_#{reflection.macro}", aliased_table, parent_table)
-
-              unless klass.descends_from_active_record?
-                sti_column = aliased_table[klass.inheritance_column]
-                sti_condition = sti_column.eq(klass.sti_name)
-                klass.descendants.each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
-
-                @join << sti_condition
-              end
-
-              [through_reflection, reflection].each do |ref|
-                if ref && ref.options[:conditions]
-                  @join << interpolate_sql(sanitize_sql(ref.options[:conditions], aliased_table_name))
-                end
-              end
-
-              @join
+            def join_relation(joining_relation)
+              self.join_class = Arel::OuterJoin
+              joining_relation.joins(self)
             end
-
-            def relation
-              aliased = Arel::Table.new(table_name, :as => @aliased_table_name,
-                                                    :engine => arel_engine,
-                                                    :columns => klass.columns)
-
-              if reflection.macro == :has_and_belongs_to_many
-                [Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine), aliased]
-              elsif reflection.options[:through]
-                [Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine), aliased]
-              else
-                aliased
-              end
-            end
-
-            def join_relation(joining_relation, join = nil)
-              joining_relation.joins(self.with_join_class(Arel::OuterJoin))
+            
+            def table
+              @table ||= Arel::Table.new(
+                table_name, :as => aliased_table_name,
+                :engine => arel_engine, :columns => active_record.columns
+              )
             end
+            
+            # More semantic name given we are talking about associations
+            alias_method :target_table, :table
 
             protected
 
@@ -2193,74 +2218,169 @@ module ActiveRecord
               end
 
             private
+            
+            def allocate_aliases
+              @aliased_prefix     = "t#{ join_dependency.joins.size }"
+              @aliased_table_name = aliased_table_name_for(table_name)
+              
+              if reflection.macro == :has_and_belongs_to_many
+                @aliased_join_table_name = aliased_table_name_for(reflection.options[:join_table], "_join")
+              elsif [:has_many, :has_one].include?(reflection.macro) && reflection.options[:through]
+                @aliased_join_table_name = aliased_table_name_for(reflection.through_reflection.klass.table_name, "_join")
+              end
+            end
+            
+            def process_conditions(conditions, table_name)
+              Arel.sql(interpolate_sql(sanitize_sql(conditions, table_name)))
+            end
+            
+            def join_target_table(relation, *conditions)
+              relation = relation.join(target_table, join_class)
+              
+              # If the target table is an STI model then we must be sure to only include records of
+              # its type and its sub-types.
+              unless active_record.descends_from_active_record?
+                sti_column = target_table[active_record.inheritance_column]
+                
+                sti_condition = sti_column.eq(active_record.sti_name)
+                active_record.descendants.each do |subclass|
+                  sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name))
+                end
+                
+                conditions << sti_condition
+              end
+              
+              # If the reflection has conditions, add them
+              if options[:conditions]
+                conditions << process_conditions(options[:conditions], aliased_table_name)
+              end
+              
+              relation = relation.on(*conditions)
+            end
 
-            def build_has_and_belongs_to_many(aliased_table, parent_table)
-              join_table = Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine)
-              fk = options[:foreign_key] || reflection.active_record.to_s.foreign_key
-              klass_fk = options[:association_foreign_key] || klass.to_s.foreign_key
-
-              [
-                join_table[fk].eq(parent_table[reflection.active_record.primary_key]),
-                aliased_table[klass.primary_key].eq(join_table[klass_fk])
-              ]
+            def join_has_and_belongs_to_many_to(relation)
+              join_table = Arel::Table.new(
+                options[:join_table], :engine => arel_engine,
+                :as => @aliased_join_table_name
+              )
+              
+              fk       = options[:foreign_key]             || reflection.active_record.to_s.foreign_key
+              klass_fk = options[:association_foreign_key] || reflection.klass.to_s.foreign_key
+              
+              relation = relation.join(join_table, join_class)
+              relation = relation.on(
+                join_table[fk].
+                  eq(parent_table[reflection.active_record.primary_key])
+              )
+              
+              join_target_table(
+                relation,
+                target_table[reflection.klass.primary_key].
+                  eq(join_table[klass_fk])
+              )
             end
 
-            def build_has_many(aliased_table, parent_table)
+            def join_has_many_to(relation)
               if reflection.options[:through]
-                join_table = Arel::Table.new(through_reflection.klass.table_name,
-                                             :as     => aliased_join_table_name,
-                                             :engine => arel_engine)
-                jt_foreign_key = jt_as_extra = jt_source_extra = jt_sti_extra = nil
-                first_key = second_key = nil
-
-                if through_reflection.options[:as] # has_many :through against a polymorphic join
-                  as_key         = through_reflection.options[:as].to_s
-                  jt_foreign_key = as_key + '_id'
-                  jt_as_extra    = join_table[as_key + '_type'].eq(parent.active_record.base_class.name)
-                else
-                  jt_foreign_key = through_reflection.primary_key_name
-                end
-
-                case source_reflection.macro
-                when :has_many
-                  second_key  = options[:foreign_key] || primary_key
+                join_has_many_through_to(relation)
+              elsif reflection.options[:as]
+                join_has_many_polymorphic_to(relation)
+              else
+                foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
+                primary_key = options[:primary_key] || parent.primary_key
+                
+                join_target_table(
+                  relation,
+                  target_table[foreign_key].
+                    eq(parent_table[primary_key])
+                )
+              end
+            end
+            alias :join_has_one_to :join_has_many_to
+            
+            def join_has_many_through_to(relation)
+              join_table = Arel::Table.new(
+                through_reflection.klass.table_name, :engine => arel_engine,
+                :as => @aliased_join_table_name
+              )
+              
+              jt_conditions = []
+              jt_foreign_key = first_key = second_key = nil
+
+              if through_reflection.options[:as] # has_many :through against a polymorphic join
+                as_key         = through_reflection.options[:as].to_s
+                jt_foreign_key = as_key + '_id'
+                
+                jt_conditions <<
+                  join_table[as_key + '_type'].
+                    eq(parent.active_record.base_class.name)
+              else
+                jt_foreign_key = through_reflection.primary_key_name
+              end
 
-                  if source_reflection.options[:as]
-                    first_key   = "#{source_reflection.options[:as]}_id"
-                  else
-                    first_key   = through_reflection.klass.base_class.to_s.foreign_key
-                  end
+              case source_reflection.macro
+              when :has_many
+                second_key = options[:foreign_key] || primary_key
 
-                  unless through_reflection.klass.descends_from_active_record?
-                    jt_sti_extra = join_table[through_reflection.active_record.inheritance_column].eq(through_reflection.klass.sti_name)
-                  end
-                when :belongs_to
-                  first_key = primary_key
-                  if reflection.options[:source_type]
-                    second_key = source_reflection.association_foreign_key
-                    jt_source_extra = join_table[reflection.source_reflection.options[:foreign_type]].eq(reflection.options[:source_type])
-                  else
-                    second_key = source_reflection.primary_key_name
-                  end
+                if source_reflection.options[:as]
+                  first_key = "#{source_reflection.options[:as]}_id"
+                else
+                  first_key = through_reflection.klass.base_class.to_s.foreign_key
                 end
 
-                [
-                  [parent_table[parent.primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra].compact,
-                  aliased_table[first_key].eq(join_table[second_key])
-                ]
-              elsif reflection.options[:as]
-                id_rel = aliased_table["#{reflection.options[:as]}_id"].eq(parent_table[parent.primary_key])
-                type_rel = aliased_table["#{reflection.options[:as]}_type"].eq(parent.active_record.base_class.name)
-                [id_rel, type_rel]
-              else
-                foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
-                [aliased_table[foreign_key].eq(parent_table[reflection.options[:primary_key] || parent.primary_key])]
+                unless through_reflection.klass.descends_from_active_record?
+                  jt_conditions <<
+                    join_table[through_reflection.active_record.inheritance_column].
+                      eq(through_reflection.klass.sti_name)
+                end
+              when :belongs_to
+                first_key = primary_key
+                
+                if reflection.options[:source_type]
+                  second_key = source_reflection.association_foreign_key
+                  
+                  jt_conditions <<
+                    join_table[reflection.source_reflection.options[:foreign_type]].
+                      eq(reflection.options[:source_type])
+                else
+                  second_key = source_reflection.primary_key_name
+                end
+              end
+              
+              jt_conditions <<
+                parent_table[parent.primary_key].
+                  eq(join_table[jt_foreign_key])
+              
+              if through_reflection.options[:conditions]
+                jt_conditions << process_conditions(through_reflection.options[:conditions], aliased_table_name)
               end
+              
+              relation = relation.join(join_table, join_class).on(*jt_conditions)
+              
+              join_target_table(
+                relation,
+                target_table[first_key].eq(join_table[second_key])
+              )
+            end
+            
+            def join_has_many_polymorphic_to(relation)
+              join_target_table(
+                relation,
+                target_table["#{reflection.options[:as]}_id"].
+                  eq(parent_table[parent.primary_key]),
+                target_table["#{reflection.options[:as]}_type"].
+                  eq(parent.active_record.base_class.name)
+              )
             end
-            alias :build_has_one :build_has_many
 
-            def build_belongs_to(aliased_table, parent_table)
-              [aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name])]
+            def join_belongs_to_to(relation)
+              foreign_key = options[:foreign_key] || reflection.primary_key_name
+              primary_key = options[:primary_key] || reflection.klass.primary_key
+              
+              join_target_table(
+                relation,
+                target_table[primary_key].eq(parent_table[foreign_key])
+              )
             end
           end
         end
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index a5dc051c6e..59ce76ea42 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -221,19 +221,8 @@ module ActiveRecord
 
       @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
 
-      to_join = []
-
       join_dependency.join_associations.each do |association|
-        if (association_relation = association.relation).is_a?(Array)
-          to_join << [association_relation.first, association.join_class, association.association_join.first]
-          to_join << [association_relation.last, association.join_class, association.association_join.last]
-        else
-          to_join << [association_relation, association.join_class, association.association_join]
-        end
-      end
-
-      to_join.uniq.each do |left, join_class, right|
-        relation = relation.join(left, join_class).on(*right)
+        relation = association.join_to(relation)
       end
 
       relation.join(custom_joins)
-- 
cgit v1.2.3


From 19304a9758ac4b98a0b98b5849eeb6ffdac028f4 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Wed, 13 Oct 2010 12:16:53 +0100
Subject: Renaming and formatting changes in JoinDependency

---
 activerecord/lib/active_record/associations.rb     | 98 +++++++++++-----------
 .../lib/active_record/relation/finder_methods.rb   |  7 +-
 2 files changed, 56 insertions(+), 49 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index bf13898e92..a28117b732 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -1833,10 +1833,10 @@ module ActiveRecord
         end
 
         class JoinDependency # :nodoc:
-          attr_reader :joins, :reflections, :table_aliases
+          attr_reader :join_parts, :reflections, :table_aliases
 
           def initialize(base, associations, joins)
-            @joins                 = [JoinBase.new(base, joins)]
+            @join_parts            = [JoinBase.new(base, joins)]
             @associations          = associations
             @reflections           = []
             @base_records_hash     = {}
@@ -1849,17 +1849,17 @@ module ActiveRecord
           def graft(*associations)
             associations.each do |association|
               join_associations.detect {|a| association == a} ||
-              build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_class)
+              build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type)
             end
             self
           end
 
           def join_associations
-            @joins.last(@joins.length - 1)
+            join_parts.last(join_parts.length - 1)
           end
 
           def join_base
-            @joins[0]
+            join_parts.first
           end
 
           def count_aliases_from_table_joins(name)
@@ -1917,24 +1917,24 @@ module ActiveRecord
 
           protected
 
-            def build(associations, parent = nil, join_class = Arel::InnerJoin)
-              parent ||= @joins.last
+            def build(associations, parent = nil, join_type = Arel::InnerJoin)
+              parent ||= join_parts.last
               case associations
                 when Symbol, String
                   reflection = parent.reflections[associations.to_s.intern] or
                   raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
                   @reflections << reflection
                   join_association = build_join_association(reflection, parent)
-                  join_association.join_class = join_class
-                  @joins << join_association
+                  join_association.join_type = join_type
+                  @join_parts << join_association
                 when Array
                   associations.each do |association|
-                    build(association, parent, join_class)
+                    build(association, parent, join_type)
                   end
                 when Hash
                   associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
-                    build(name, parent, join_class)
-                    build(associations[name], nil, join_class)
+                    build(name, parent, join_type)
+                    build(associations[name], nil, join_type)
                   end
                 else
                   raise ConfigurationError, associations.inspect
@@ -1951,60 +1951,64 @@ module ActiveRecord
               JoinAssociation.new(reflection, self, parent)
             end
 
-            def construct(parent, associations, joins, row)
+            def construct(parent, associations, join_parts, row)
               case associations
               when Symbol, String
-                join = joins.detect{|j| j.reflection.name.to_s == associations.to_s && j.parent_table_name == parent.class.table_name }
-                raise(ConfigurationError, "No such association") if join.nil?
+                join_part = join_parts.detect { |j|
+                  j.reflection.name.to_s == associations.to_s &&
+                  j.parent_table_name    == parent.class.table_name }
+                raise(ConfigurationError, "No such association") if join_part.nil?
 
-                joins.delete(join)
-                construct_association(parent, join, row)
+                join_parts.delete(join_part)
+                construct_association(parent, join_part, row)
               when Array
                 associations.each do |association|
-                  construct(parent, association, joins, row)
+                  construct(parent, association, join_parts, row)
                 end
               when Hash
                 associations.sort_by { |k,_| k.to_s }.each do |name, assoc|
-                  join = joins.detect{|j| j.reflection.name.to_s == name.to_s && j.parent_table_name == parent.class.table_name }
-                  raise(ConfigurationError, "No such association") if join.nil?
-
-                  association = construct_association(parent, join, row)
-                  joins.delete(join)
-                  construct(association, assoc, joins, row) if association
+                  join_part = join_parts.detect{ |j|
+                    j.reflection.name.to_s == name.to_s &&
+                    j.parent_table_name    == parent.class.table_name }
+                  raise(ConfigurationError, "No such association") if join_part.nil?
+
+                  association = construct_association(parent, join_part, row)
+                  join_parts.delete(join_part)
+                  construct(association, assoc, join_parts, row) if association
                 end
               else
                 raise ConfigurationError, associations.inspect
               end
             end
 
-            def construct_association(record, join, row)
-              return if record.id.to_s != join.parent.record_id(row).to_s
+            def construct_association(record, join_part, row)
+              return if record.id.to_s != join_part.parent.record_id(row).to_s
 
-              macro = join.reflection.macro
+              macro = join_part.reflection.macro
               if macro == :has_one
-                return if record.instance_variable_defined?("@#{join.reflection.name}")
-                association = join.instantiate(row) unless row[join.aliased_primary_key].nil?
-                set_target_and_inverse(join, association, record)
+                return if record.instance_variable_defined?("@#{join_part.reflection.name}")
+                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.aliased_primary_key].nil?
-                association = join.instantiate(row)
+                return if row[join_part.aliased_primary_key].nil?
+                association = join_part.instantiate(row)
                 case macro
                 when :has_many, :has_and_belongs_to_many
-                  collection = record.send(join.reflection.name)
+                  collection = record.send(join_part.reflection.name)
                   collection.loaded
                   collection.target.push(association)
                   collection.__send__(:set_inverse_instance, association, record)
                 when :belongs_to
-                  set_target_and_inverse(join, association, record)
+                  set_target_and_inverse(join_part, association, record)
                 else
-                  raise ConfigurationError, "unknown macro: #{join.reflection.macro}"
+                  raise ConfigurationError, "unknown macro: #{join_part.reflection.macro}"
                 end
               end
               association
             end
 
-            def set_target_and_inverse(join, association, record)
-              association_proxy = record.send("set_#{join.reflection.name}_target", association)
+            def set_target_and_inverse(join_part, association, record)
+              association_proxy = record.send("set_#{join_part.reflection.name}_target", association)
               association_proxy.__send__(:set_inverse_instance, association, record)
             end
           
@@ -2119,7 +2123,7 @@ module ActiveRecord
             attr_reader :parent
             
             # What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
-            attr_accessor :join_class
+            attr_accessor :join_type
             
             # These implement abstract methods from the superclass
             attr_reader :aliased_prefix, :aliased_table_name
@@ -2139,7 +2143,7 @@ module ActiveRecord
               @reflection      = reflection
               @join_dependency = join_dependency
               @parent          = parent
-              @join_class       = Arel::InnerJoin
+              @join_type       = Arel::InnerJoin
               
               # This must be done eagerly upon initialisation because the alias which is produced
               # depends on the state of the join dependency, but we want it to work the same way
@@ -2154,8 +2158,8 @@ module ActiveRecord
             end
 
             def find_parent_in(other_join_dependency)
-              other_join_dependency.joins.detect do |join|
-                self.parent == join
+              other_join_dependency.join_parts.detect do |join_part|
+                self.parent == join_part
               end
             end
             
@@ -2164,7 +2168,7 @@ module ActiveRecord
             end
 
             def join_relation(joining_relation)
-              self.join_class = Arel::OuterJoin
+              self.join_type = Arel::OuterJoin
               joining_relation.joins(self)
             end
             
@@ -2210,7 +2214,7 @@ module ActiveRecord
               end
 
               def table_name_and_alias
-                table_alias_for table_name, @aliased_table_name
+                table_alias_for table_name, aliased_table_name
               end
 
               def interpolate_sql(sql)
@@ -2220,7 +2224,7 @@ module ActiveRecord
             private
             
             def allocate_aliases
-              @aliased_prefix     = "t#{ join_dependency.joins.size }"
+              @aliased_prefix     = "t#{ join_dependency.join_parts.size }"
               @aliased_table_name = aliased_table_name_for(table_name)
               
               if reflection.macro == :has_and_belongs_to_many
@@ -2235,7 +2239,7 @@ module ActiveRecord
             end
             
             def join_target_table(relation, *conditions)
-              relation = relation.join(target_table, join_class)
+              relation = relation.join(target_table, join_type)
               
               # If the target table is an STI model then we must be sure to only include records of
               # its type and its sub-types.
@@ -2267,7 +2271,7 @@ module ActiveRecord
               fk       = options[:foreign_key]             || reflection.active_record.to_s.foreign_key
               klass_fk = options[:association_foreign_key] || reflection.klass.to_s.foreign_key
               
-              relation = relation.join(join_table, join_class)
+              relation = relation.join(join_table, join_type)
               relation = relation.on(
                 join_table[fk].
                   eq(parent_table[reflection.active_record.primary_key])
@@ -2355,7 +2359,7 @@ module ActiveRecord
                 jt_conditions << process_conditions(through_reflection.options[:conditions], aliased_table_name)
               end
               
-              relation = relation.join(join_table, join_class).on(*jt_conditions)
+              relation = relation.join(join_table, join_type).on(*jt_conditions)
               
               join_target_table(
                 relation,
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index e950dce62b..b763e22ec6 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -343,8 +343,11 @@ module ActiveRecord
     end
 
     def column_aliases(join_dependency)
-      join_dependency.joins.collect{|join| join.column_names_with_alias.collect{|column_name, aliased_name|
-          "#{connection.quote_table_name join.aliased_table_name}.#{connection.quote_column_name column_name} AS #{aliased_name}"}}.flatten.join(", ")
+      join_dependency.join_parts.collect { |join_part|
+        join_part.column_names_with_alias.collect{ |column_name, aliased_name|
+          "#{connection.quote_table_name join_part.aliased_table_name}.#{connection.quote_column_name column_name} AS #{aliased_name}"
+        }
+      }.flatten.join(", ")
     end
 
     def using_limitable_reflections?(reflections)
-- 
cgit v1.2.3


From 1ddbb216eae155cd9347c7651b16a885867c542c Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Wed, 13 Oct 2010 12:28:05 +0100
Subject: Delete unused methods in JoinAssociation

---
 activerecord/lib/active_record/associations.rb | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index a28117b732..affa2fbcaf 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -2209,14 +2209,6 @@ module ActiveRecord
                 ActiveRecord::Base.pluralize_table_names ? table_name.to_s.pluralize : table_name
               end
 
-              def table_alias_for(table_name, table_alias)
-                 "#{table_name} #{table_alias if table_name != table_alias}".strip
-              end
-
-              def table_name_and_alias
-                table_alias_for table_name, aliased_table_name
-              end
-
               def interpolate_sql(sql)
                 instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
               end
-- 
cgit v1.2.3


From 941844cbe503c312692e2f78d61abaca5b4896b1 Mon Sep 17 00:00:00 2001
From: Carl Lerche <me@carllerche.com>
Date: Wed, 13 Oct 2010 11:40:47 -0700
Subject: rb_thread_select should always be used in DB drivers when available.

---
 .../lib/active_record/connection_adapters/postgresql_adapter.rb         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 5f14284615..8fbddb13bd 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -930,7 +930,7 @@ module ActiveRecord
           PGconn.translate_results = false if PGconn.respond_to?(:translate_results=)
 
           # Ignore async_exec and async_query when using postgres-pr.
-          @async = @config[:allow_concurrency] && @connection.respond_to?(:async_exec)
+          @async = @connection.respond_to?(:async_exec)
 
           # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
           # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
-- 
cgit v1.2.3


From 0b6af35ef0647cf346bc7e274fc49da64f790ab0 Mon Sep 17 00:00:00 2001
From: Carl Lerche <me@carllerche.com>
Date: Wed, 13 Oct 2010 11:49:32 -0700
Subject: Update the PostgreSQL adapter documentation

---
 .../lib/active_record/connection_adapters/postgresql_adapter.rb         | 2 --
 1 file changed, 2 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 8fbddb13bd..dce9e99d27 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -180,8 +180,6 @@ module ActiveRecord
     #   <encoding></tt> call on the connection.
     # * <tt>:min_messages</tt> - An optional client min messages that is used in a
     #   <tt>SET client_min_messages TO <min_messages></tt> call on the connection.
-    # * <tt>:allow_concurrency</tt> - If true, use async query methods so Ruby threads don't deadlock;
-    #   otherwise, use blocking query methods.
     class PostgreSQLAdapter < AbstractAdapter
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         def xml(*args)
-- 
cgit v1.2.3


From 91ba75806f20195b06b9a2197cf5f40a238231d5 Mon Sep 17 00:00:00 2001
From: Carl Lerche <me@carllerche.com>
Date: Wed, 13 Oct 2010 12:32:52 -0700
Subject: Update the ActiveRecord tests to not set unused options

	This makes a test fail, but it is revealing a bug in Arel master.
---
 activerecord/lib/active_record/test_case.rb | 15 ---------------
 1 file changed, 15 deletions(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/test_case.rb b/activerecord/lib/active_record/test_case.rb
index 31b5a8651b..014a900c71 100644
--- a/activerecord/lib/active_record/test_case.rb
+++ b/activerecord/lib/active_record/test_case.rb
@@ -36,21 +36,6 @@ module ActiveRecord
       assert_queries(0, &block)
     end
 
-    def self.use_concurrent_connections
-      setup :connection_allow_concurrency_setup
-      teardown :connection_allow_concurrency_teardown
-    end
-
-    def connection_allow_concurrency_setup
-      @connection = ActiveRecord::Base.remove_connection
-      ActiveRecord::Base.establish_connection(@connection.merge({:allow_concurrency => true}))
-    end
-
-    def connection_allow_concurrency_teardown
-      ActiveRecord::Base.clear_all_connections!
-      ActiveRecord::Base.establish_connection(@connection)
-    end
-
     def with_kcode(kcode)
       if RUBY_VERSION < '1.9'
         orig_kcode, $KCODE = $KCODE, kcode
-- 
cgit v1.2.3


From f07cbec865093c30299ad038d52e3e70e2527848 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Sun, 10 Oct 2010 15:03:57 +0200
Subject: Do not treat information about skipped migrations as WARNINGs but as
 a NOTEs, also puts to stdin

---
 activerecord/lib/active_record/railties/databases.rake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 5ad440e58d..1fbc8a1d32 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -494,7 +494,7 @@ namespace :railties do
       end
 
       on_skip = Proc.new do |name, migration|
-        $stderr.puts "WARNING: Migration #{migration.basename} from #{name} has been skipped. Migration with the same name already exists."
+        puts "NOTE: Migration #{migration.basename} from #{name} has been skipped. Migration with the same name already exists."
       end
 
       on_copy = Proc.new do |name, migration, old_path|
-- 
cgit v1.2.3