activerecord 4.0.0.beta1 → 4.0.0.rc1

data/lib/active_record/persistence.rb

@@ -51,7 +51,7 @@ module ActiveRecord
       # how this "single-table" inheritance mapping is implemented.
       def instantiate(record, column_types = {})
         klass = discriminate_class_for_record(record)
-        column_types = klass.decorate_columns(column_types)
+        column_types = klass.decorate_columns(column_types.dup)
         klass.allocate.init_with('attributes' => record, 'column_types' => column_types)
       end
 
@@ -410,7 +410,7 @@ module ActiveRecord
     def relation_for_destroy
       pk         = self.class.primary_key
       column     = self.class.columns_hash[pk]
-      substitute = connection.substitute_at(column, 0)
+      substitute = self.class.connection.substitute_at(column, 0)
 
       relation = self.class.unscoped.where(
         self.class.arel_table[pk].eq(substitute))
@@ -443,7 +443,7 @@ module ActiveRecord
           real_column = db_columns_with_values[i].first
           bind_attrs[column] = klass.connection.substitute_at(real_column, i)
         end
-        stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id)).arel.compile_update(bind_attrs)
+        stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id_was || id)).arel.compile_update(bind_attrs)
         klass.connection.update stmt, 'SQL', db_columns_with_values
       end
     end

data/lib/active_record/querying.rb

@@ -8,7 +8,7 @@ module ActiveRecord
     delegate :find_each, :find_in_batches, :to => :all
     delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins,
              :where, :preload, :eager_load, :includes, :from, :lock, :readonly,
-             :having, :create_with, :uniq, :references, :none, :to => :all
+             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, :to => :all
     delegate :count, :average, :minimum, :maximum, :sum, :calculate, :pluck, :ids, :to => :all
 
     # Executes a custom SQL query against your database and returns all the results. The results will

data/lib/active_record/railtie.rb

@@ -36,6 +36,20 @@ module ActiveRecord
 
     rake_tasks do
       require "active_record/base"
+
+      ActiveRecord::Tasks::DatabaseTasks.env = Rails.env
+      ActiveRecord::Tasks::DatabaseTasks.db_dir = Rails.application.config.paths["db"].first
+      ActiveRecord::Tasks::DatabaseTasks.seed_loader = Rails.application
+      ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = Rails.application.paths['db/migrate'].to_a
+      ActiveRecord::Tasks::DatabaseTasks.fixtures_path = File.join Rails.root, 'test', 'fixtures'
+
+      if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
+        if engine.paths['db/migrate'].existent
+          ActiveRecord::Tasks::DatabaseTasks.migrations_paths += engine.paths['db/migrate'].to_a
+        end
+      end
+
       load "active_record/railties/databases.rake"
     end
 
@@ -49,7 +63,7 @@ module ActiveRecord
       Rails.logger.extend ActiveSupport::Logger.broadcast console
     end
 
-    runner do |app|
+    runner do
       require "active_record/base"
     end
 
@@ -64,7 +78,7 @@ module ActiveRecord
       ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
     end
 
-    initializer "active_record.migration_error" do |app|
+    initializer "active_record.migration_error" do
       if config.active_record.delete(:migration_error) == :page_load
         config.app_middleware.insert_after "::ActionDispatch::Callbacks",
           "ActiveRecord::Migration::CheckPending"
@@ -152,13 +166,13 @@ module ActiveRecord
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
       ActiveSupport.on_load(:active_record) do
-        self.configurations = app.config.database_configuration
+        self.configurations = app.config.database_configuration || {}
         establish_connection
       end
     end
 
     # Expose database runtime to controller for logging.
-    initializer "active_record.log_runtime" do |app|
+    initializer "active_record.log_runtime" do
       require "active_record/railties/controller_runtime"
       ActiveSupport.on_load(:action_controller) do
         include ActiveRecord::Railties::ControllerRuntime

data/lib/active_record/railties/console_sandbox.rb

@@ -1,4 +1,5 @@
-ActiveRecord::Base.connection.begin_db_transaction
+ActiveRecord::Base.connection.begin_transaction(joinable: false)
+
 at_exit do
-  ActiveRecord::Base.connection.rollback_db_transaction
+  ActiveRecord::Base.connection.rollback_transaction
 end

data/lib/active_record/railties/controller_runtime.rb

@@ -21,9 +21,10 @@ module ActiveRecord
       def cleanup_view_runtime
         if ActiveRecord::Base.connected?
           db_rt_before_render = ActiveRecord::LogSubscriber.reset_runtime
+          self.db_runtime = (db_runtime || 0) + db_rt_before_render
           runtime = super
           db_rt_after_render = ActiveRecord::LogSubscriber.reset_runtime
-          self.db_runtime = db_rt_before_render + db_rt_after_render
+          self.db_runtime += db_rt_after_render
           runtime - db_rt_after_render
         else
           super

data/lib/active_record/railties/databases.rake

@@ -2,14 +2,8 @@ require 'active_record'
 
 db_namespace = namespace :db do
   task :load_config do
-    ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-    ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
-
-    if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
-      if engine.paths['db/migrate'].existent
-        ActiveRecord::Migrator.migrations_paths += engine.paths['db/migrate'].to_a
-      end
-    end
+    ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
+    ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
   end
 
   namespace :create do
@@ -156,7 +150,7 @@ db_namespace = namespace :db do
     begin
       puts ActiveRecord::Tasks::DatabaseTasks.collation_current
     rescue NoMethodError
-      $stderr.puts 'Sorry, your database adapter is not supported yet, feel free to submit a patch'
+      $stderr.puts 'Sorry, your database adapter is not supported yet. Feel free to submit a patch.'
     end
   end
 
@@ -166,11 +160,11 @@ db_namespace = namespace :db do
   end
 
   # desc "Raises an error if there are pending migrations"
-  task :abort_if_pending_migrations => [:environment, :load_config] do
+  task :abort_if_pending_migrations => :environment do
     pending_migrations = ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).pending_migrations
 
     if pending_migrations.any?
-      puts "You have #{pending_migrations.size} pending migrations:"
+      puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
       pending_migrations.each do |pending_migration|
         puts '  %4d %s' % [pending_migration.version, pending_migration.name]
       end
@@ -184,7 +178,7 @@ db_namespace = namespace :db do
   desc 'Load the seed data from db/seeds.rb'
   task :seed do
     db_namespace['abort_if_pending_migrations'].invoke
-    Rails.application.load_seed
+    ActiveRecord::Tasks::DatabaseTasks.load_seed
   end
 
   namespace :fixtures do
@@ -192,7 +186,15 @@ db_namespace = namespace :db do
     task :load => [:environment, :load_config] do
       require 'active_record/fixtures'
 
-      base_dir     = File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
+      base_dir = if ENV['FIXTURES_PATH']
+        STDERR.puts "Using FIXTURES_PATH env variable is deprecated, please use " +
+                    "ActiveRecord::Tasks::DatabaseTasks.fixtures_path = '/path/to/fixtures' " +
+                    "instead."
+        File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
+      else
+        ActiveRecord::Tasks::DatabaseTasks.fixtures_path
+      end
+
       fixtures_dir = File.join [base_dir, ENV['FIXTURES_DIR']].compact
 
       (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
@@ -209,7 +211,16 @@ db_namespace = namespace :db do
 
       puts %Q(The fixture ID for "#{label}" is #{ActiveRecord::FixtureSet.identify(label)}.) if label
 
-      base_dir = ENV['FIXTURES_PATH'] ? File.join(Rails.root, ENV['FIXTURES_PATH']) : File.join(Rails.root, 'test', 'fixtures')
+      base_dir = if ENV['FIXTURES_PATH']
+        STDERR.puts "Using FIXTURES_PATH env variable is deprecated, please use " +
+                    "ActiveRecord::Tasks::DatabaseTasks.fixtures_path = '/path/to/fixtures' " +
+                    "instead."
+        File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
+      else
+        ActiveRecord::Tasks::DatabaseTasks.fixtures_path
+      end
+
+
       Dir["#{base_dir}/**/*.yml"].each do |file|
         if data = YAML::load(ERB.new(IO.read(file)).result)
           data.keys.each do |key|
@@ -228,7 +239,7 @@ 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 => [:environment, :load_config] do
       require 'active_record/schema_dumper'
-      filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
+      filename = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
       File.open(filename, "w:utf-8") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
@@ -237,11 +248,11 @@ db_namespace = namespace :db do
 
     desc 'Load a schema.rb file into the database'
     task :load => [:environment, :load_config] do
-      file = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
+      file = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
       if File.exists?(file)
         load(file)
       else
-        abort %{#{file} doesn't exist yet. Run `rake db:migrate` to create it then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded}
+        abort %{#{file} doesn't exist yet. Run `rake db:migrate` to create it, then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.}
       end
     end
 
@@ -253,7 +264,7 @@ db_namespace = namespace :db do
       desc 'Create a db/schema_cache.dump file.'
       task :dump => [:environment, :load_config] do
         con = ActiveRecord::Base.connection
-        filename = File.join(Rails.application.config.paths["db"].first, "schema_cache.dump")
+        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.dump")
 
         con.schema_cache.clear!
         con.tables.each { |table| con.schema_cache.add(table) }
@@ -262,7 +273,7 @@ db_namespace = namespace :db do
 
       desc 'Clear a db/schema_cache.dump file.'
       task :clear => [:environment, :load_config] do
-        filename = File.join(Rails.application.config.paths["db"].first, "schema_cache.dump")
+        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.dump")
         FileUtils.rm(filename) if File.exists?(filename)
       end
     end
@@ -270,32 +281,11 @@ db_namespace = namespace :db do
   end
 
   namespace :structure do
-    def set_firebird_env(config)
-      ENV['ISC_USER']     = config['username'].to_s if config['username']
-      ENV['ISC_PASSWORD'] = config['password'].to_s if config['password']
-    end
-
-    def firebird_db_string(config)
-      FireRuby::Database.db_string_for(config.symbolize_keys)
-    end
-
     desc 'Dump the database structure to db/structure.sql. Specify another file with DB_STRUCTURE=db/my_structure.sql'
     task :dump => [:environment, :load_config] do
-      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
+      filename = ENV['DB_STRUCTURE'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
-      case current_config['adapter']
-      when 'oci', 'oracle'
-        ActiveRecord::Base.establish_connection(current_config)
-        File.open(filename, "w:utf-8") { |f| f << ActiveRecord::Base.connection.structure_dump }
-      when 'sqlserver'
-        `smoscript -s #{current_config['host']} -d #{current_config['database']} -u #{current_config['username']} -p #{current_config['password']} -f #{filename} -A -U`
-      when "firebird"
-        set_firebird_env(current_config)
-        db_string = firebird_db_string(current_config)
-        sh "isql -a #{db_string} > #{filename}"
-      else
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
-      end
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
 
       if ActiveRecord::Base.connection.supports_migrations?
         File.open(filename, "a") do |f|
@@ -307,23 +297,9 @@ db_namespace = namespace :db do
 
     # desc "Recreate the databases from the structure.sql file"
     task :load => [:environment, :load_config] do
+      filename = ENV['DB_STRUCTURE'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
-      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
-      case current_config['adapter']
-      when 'sqlserver'
-        `sqlcmd -S #{current_config['host']} -d #{current_config['database']} -U #{current_config['username']} -P #{current_config['password']} -i #{filename}`
-      when 'oci', 'oracle'
-        ActiveRecord::Base.establish_connection(current_config)
-        IO.read(filename).split(";\n\n").each do |ddl|
-          ActiveRecord::Base.connection.execute(ddl)
-        end
-      when 'firebird'
-        set_firebird_env(current_config)
-        db_string = firebird_db_string(current_config)
-        sh "isql -i #{filename} #{db_string}"
-      else
-        ActiveRecord::Tasks::DatabaseTasks.structure_load(current_config, filename)
-      end
+      ActiveRecord::Tasks::DatabaseTasks.structure_load(current_config, filename)
     end
 
     task :load_if_sql => ['db:create', :environment] do
@@ -378,29 +354,11 @@ db_namespace = namespace :db do
 
     # desc "Empty the test database"
     task :purge => [:environment, :load_config] do
-      abcs = ActiveRecord::Base.configurations
-      case abcs['test']['adapter']
-      when 'sqlserver'
-        test = abcs.deep_dup['test']
-        test_database = test['database']
-        test['database'] = 'master'
-        ActiveRecord::Base.establish_connection(test)
-        ActiveRecord::Base.connection.recreate_database!(test_database)
-      when "oci", "oracle"
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
-          ActiveRecord::Base.connection.execute(ddl)
-        end
-      when 'firebird'
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.recreate_database!
-      else
-        ActiveRecord::Tasks::DatabaseTasks.purge abcs['test']
-      end
+      ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations['test']
     end
 
     # desc 'Check for pending migrations and load the test schema'
-    task :prepare => 'db:abort_if_pending_migrations' do
+    task :prepare do
       unless ActiveRecord::Base.configurations.blank?
         db_namespace['test:load'].invoke
       end
@@ -426,7 +384,7 @@ namespace :railties do
         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|
+      on_copy = Proc.new do |name, migration|
         puts "Copied migration #{migration.basename} from #{name}"
       end
 
@@ -436,5 +394,5 @@ namespace :railties do
   end
 end
 
-task 'test:prepare' => 'db:test:prepare'
+task 'test:prepare' => ['db:test:prepare', 'db:test:load', 'db:abort_if_pending_migrations']
 

data/lib/active_record/reflection.rb

@@ -75,8 +75,13 @@ module ActiveRecord
       end
     end
 
-    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
+    # Base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    #
+    #   MacroReflection
+    #     AggregateReflection
+    #     AssociationReflection
+    #       ThroughReflection
     class MacroReflection
       # Returns the name of the macro.
       #
@@ -401,6 +406,16 @@ module ActiveRecord
       #     has_many :tags, through: :taggings
       #   end
       #
+      #   class Tagging < ActiveRecord::Base
+      #     belongs_to :post
+      #     belongs_to :tag
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #
+      #   taggings_reflection = tags_reflection.source_reflection
+      #   # => <ActiveRecord::Reflection::AssociationReflection: @macro=:belongs_to, @name=:tag, @active_record=Tagging, @plural_name="tags">
+      #
       def source_reflection
         @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
       end
@@ -426,6 +441,17 @@ module ActiveRecord
       # The chain is built by recursively calling #chain on the source reflection and the through
       # reflection. The base case for the recursion is a normal association, which just returns
       # [self] as its #chain.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   tags_reflection.chain
+      #   # => [<ActiveRecord::Reflection::ThroughReflection: @macro=:has_many, @name=:tags, @options={:through=>:taggings}, @active_record=Post>,
+      #         <ActiveRecord::Reflection::AssociationReflection: @macro=:has_many, @name=:taggings, @options={}, @active_record=Post>]
+      #
       def chain
         @chain ||= begin
           chain = source_reflection.chain + through_reflection.chain
@@ -496,9 +522,16 @@ module ActiveRecord
         source_reflection.options[:primary_key] || primary_key(klass || self.klass)
       end
 
-      # Gets an array of possible <tt>:through</tt> source reflection names:
+      # Gets an array of possible <tt>:through</tt> source reflection names in both singular and plural form.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
       #
-      #   [:singularized, :pluralized]
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   tags_reflection.source_reflection_names
+      #   # => [:tag, :tags]
       #
       def source_reflection_names
         @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }

data/lib/active_record/relation.rb

@@ -10,14 +10,14 @@ module ActiveRecord
                             :extending]
 
     SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
-                            :reverse_order, :uniq, :create_with]
+                            :reverse_order, :distinct, :create_with, :uniq]
 
     VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
 
     attr_reader :table, :klass, :loaded
-    attr_accessor :default_scoped
+    attr_accessor :default_scoped, :proxy_association
     alias :model :klass
     alias :loaded? :loaded
     alias :default_scoped? :default_scoped
@@ -188,8 +188,7 @@ module ActiveRecord
     # Please see further details in the
     # {Active Record Query Interface guide}[http://guides.rubyonrails.org/active_record_querying.html#running-explain].
     def explain
-      _, queries = collecting_queries_for_explain { exec_queries }
-      exec_explain(queries)
+      exec_explain(collecting_queries_for_explain { exec_queries })
     end
 
     # Converts relation objects to Array.
@@ -236,8 +235,9 @@ module ActiveRecord
     # Scope all queries to the current scope.
     #
     #   Comment.where(post_id: 1).scoping do
-    #     Comment.first # SELECT * FROM comments WHERE post_id = 1
+    #     Comment.first
     #   end
+    #   # => SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 ORDER BY "comments"."id" ASC LIMIT 1
     #
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
@@ -506,6 +506,12 @@ module ActiveRecord
       includes_values & joins_values
     end
 
+    # +uniq+ and +uniq!+ are silently deprecated. +uniq_value+ delegates to +distinct_value+
+    # to maintain backwards compatibility. Use +distinct_value+ instead.
+    def uniq_value
+      distinct_value
+    end
+
     # Compares two relations for equality.
     def ==(other)
       case other
@@ -589,21 +595,25 @@ module ActiveRecord
 
       if (references_values - joined_tables).any?
         true
-      elsif (string_tables - joined_tables).any?
+      elsif !ActiveRecord::Base.disable_implicit_join_references &&
+            (string_tables - joined_tables).any?
         ActiveSupport::Deprecation.warn(
           "It looks like you are eager loading table(s) (one of: #{string_tables.join(', ')}) " \
           "that are referenced in a string SQL snippet. For example: \n" \
           "\n" \
           "    Post.includes(:comments).where(\"comments.title = 'foo'\")\n" \
           "\n" \
-          "Currently, Active Record recognises the table in the string, and knows to JOIN the " \
+          "Currently, Active Record recognizes the table in the string, and knows to JOIN the " \
           "comments table to the query, rather than loading comments in a separate query. " \
           "However, doing this without writing a full-blown SQL parser is inherently flawed. " \
           "Since we don't want to write an SQL parser, we are removing this functionality. " \
           "From now on, you must explicitly tell Active Record when you are referencing a table " \
           "from a string:\n" \
           "\n" \
-          "    Post.includes(:comments).where(\"comments.title = 'foo'\").references(:comments)\n\n"
+          "    Post.includes(:comments).where(\"comments.title = 'foo'\").references(:comments)\n" \
+          "\n" \
+          "If you don't rely on implicit join references you can disable the feature entirely " \
+          "by setting `config.active_record.disable_implicit_join_references = true`."
         )
         true
       else