activerecord 4.1.0 → 4.2.0

data/lib/active_record/null_relation.rb

@@ -23,7 +23,7 @@ module ActiveRecord
     end
 
     def size
-      0
+      calculate :size, nil
     end
 
     def empty?
@@ -43,18 +43,32 @@ module ActiveRecord
     end
 
     def count(*)
-      0
+      calculate :count, nil
     end
 
     def sum(*)
-      0
+      calculate :sum, nil
+    end
+
+    def average(*)
+      calculate :average, nil
+    end
+
+    def minimum(*)
+      calculate :minimum, nil
+    end
+
+    def maximum(*)
+      calculate :maximum, nil
     end
 
     def calculate(operation, _column_name, _options = {})
       # TODO: Remove _options argument as soon we remove support to
       # activerecord-deprecated_finders.
-      if operation == :count
-        0
+      if [:count, :sum, :size].include? operation
+        group_values.any? ? Hash.new : 0
+      elsif [:average, :minimum, :maximum].include?(operation) && group_values.any?
+        Hash.new
       else
         nil
       end

data/lib/active_record/persistence.rb

@@ -36,8 +36,25 @@ module ActiveRecord
         end
       end
 
+      # Creates an object (or multiple objects) and saves it to the database,
+      # if validations pass. Raises a RecordInvalid error if validations fail,
+      # unlike Base#create.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes.
+      # These describe which attributes to be created on the object, or
+      # multiple objects when given an Array of Hashes.
+      def create!(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, &block) }
+        else
+          object = new(attributes, &block)
+          object.save!
+          object
+        end
+      end
+
       # Given an attributes hash, +instantiate+ returns a new instance of
-      # the appropriate class.
+      # the appropriate class. Accepts only keys as strings.
       #
       # For example, +Post.all+ may return Comments, Messages, and Emails
       # by storing the record's subclass in a +type+ attribute. By calling
@@ -46,10 +63,10 @@ module ActiveRecord
       #
       # See +ActiveRecord::Inheritance#discriminate_class_for_record+ to see
       # 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.dup)
-        klass.allocate.init_with('attributes' => record, 'column_types' => column_types)
+      def instantiate(attributes, column_types = {})
+        klass = discriminate_class_for_record(attributes)
+        attributes = klass.attributes_builder.build_from_database(attributes, column_types)
+        klass.allocate.init_with('attributes' => attributes, 'new_record' => false)
       end
 
       private
@@ -122,7 +139,7 @@ module ActiveRecord
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
     def save!(*)
-      create_or_update || raise(RecordNotSaved)
+      create_or_update || raise(RecordNotSaved.new(nil, self))
     end
 
     # Deletes the record in the database and freezes this instance to
@@ -149,7 +166,7 @@ module ActiveRecord
     # and <tt>destroy</tt> returns +false+. See
     # ActiveRecord::Callbacks for further details.
     def destroy
-      raise ReadOnlyRecord if readonly?
+      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
       destroy_associations
       destroy_row if persisted?
       @destroyed = true
@@ -164,7 +181,7 @@ module ActiveRecord
     # and <tt>destroy!</tt> raises ActiveRecord::RecordNotDestroyed. See
     # ActiveRecord::Callbacks for further details.
     def destroy!
-      destroy || raise(ActiveRecord::RecordNotDestroyed)
+      destroy || raise(ActiveRecord::RecordNotDestroyed, self)
     end
 
     # Returns an instance of the specified +klass+ with the attributes of the
@@ -180,7 +197,6 @@ module ActiveRecord
     def becomes(klass)
       became = klass.new
       became.instance_variable_set("@attributes", @attributes)
-      became.instance_variable_set("@attributes_cache", @attributes_cache)
       became.instance_variable_set("@changed_attributes", @changed_attributes) if defined?(@changed_attributes)
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
@@ -214,6 +230,8 @@ module ActiveRecord
     #
     # This method raises an +ActiveRecord::ActiveRecordError+  if the
     # attribute is marked as readonly.
+    #
+    # See also +update_column+.
     def update_attribute(name, value)
       name = name.to_s
       verify_readonly_attribute(name)
@@ -269,7 +287,8 @@ module ActiveRecord
     # This method raises an +ActiveRecord::ActiveRecordError+ when called on new
     # objects, or when at least one of the attributes is marked as readonly.
     def update_columns(attributes)
-      raise ActiveRecordError, "cannot update on a new record object" unless persisted?
+      raise ActiveRecordError, "cannot update a new record" if new_record?
+      raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
 
       attributes.each_key do |key|
         verify_readonly_attribute(key.to_s)
@@ -394,24 +413,24 @@ module ActiveRecord
           self.class.unscoped { self.class.find(id) }
         end
 
-      @attributes.update(fresh_object.instance_variable_get('@attributes'))
-
-      @column_types           = self.class.column_types
-      @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
-      @attributes_cache       = {}
+      @attributes = fresh_object.instance_variable_get('@attributes')
+      @new_record = false
       self
     end
 
     # Saves the record with the updated_at/on attributes set to the current time.
-    # Please note that no validation is performed and only the +after_touch+
-    # callback is executed.
-    # If an attribute name is passed, that attribute is updated along with
-    # updated_at/on attributes.
+    # Please note that no validation is performed and only the +after_touch+,
+    # +after_commit+ and +after_rollback+ callbacks are executed.
+    #
+    # If attribute names are passed, they are updated along with updated_at/on
+    # attributes.
     #
-    #   product.touch               # updates updated_at/on
-    #   product.touch(:designed_at) # updates the designed_at attribute and updated_at/on
+    #   product.touch                         # updates updated_at/on
+    #   product.touch(:designed_at)           # updates the designed_at attribute and updated_at/on
+    #   product.touch(:started_at, :ended_at) # updates started_at, ended_at and updated_at/on attributes
     #
-    # If used along with +belongs_to+ then +touch+ will invoke +touch+ method on associated object.
+    # If used along with +belongs_to+ then +touch+ will invoke +touch+ method on
+    # associated object.
     #
     #   class Brake < ActiveRecord::Base
     #     belongs_to :car, touch: true
@@ -430,11 +449,11 @@ module ActiveRecord
     #   ball = Ball.new
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
-    def touch(name = nil)
+    def touch(*names)
       raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
 
       attributes = timestamp_attributes_for_update_in_model
-      attributes << name if name
+      attributes.concat(names)
 
       unless attributes.empty?
         current_time = current_time_from_proper_timezone
@@ -447,7 +466,7 @@ module ActiveRecord
 
         changes[self.class.locking_column] = increment_lock if locking_enabled?
 
-        changed_attributes.except!(*changes.keys)
+        clear_attribute_changes(changes.keys)
         primary_key = self.class.primary_key
         self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
       else
@@ -468,7 +487,7 @@ module ActiveRecord
     def relation_for_destroy
       pk         = self.class.primary_key
       column     = self.class.columns_hash[pk]
-      substitute = self.class.connection.substitute_at(column, 0)
+      substitute = self.class.connection.substitute_at(column)
 
       relation = self.class.unscoped.where(
         self.class.arel_table[pk].eq(substitute))
@@ -478,25 +497,25 @@ module ActiveRecord
     end
 
     def create_or_update
-      raise ReadOnlyRecord if readonly?
-      result = new_record? ? create_record : update_record
+      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
+      result = new_record? ? _create_record : _update_record
       result != false
     end
 
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
-    def update_record(attribute_names = @attributes.keys)
+    def _update_record(attribute_names = self.attribute_names)
       attributes_values = arel_attributes_with_values_for_update(attribute_names)
       if attributes_values.empty?
         0
       else
-        self.class.unscoped.update_record attributes_values, id, id_was
+        self.class.unscoped._update_record attributes_values, id, id_was
       end
     end
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
-    def create_record(attribute_names = @attributes.keys)
+    def _create_record(attribute_names = self.attribute_names)
       attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
       new_id = self.class.unscoped.insert attributes_values

data/lib/active_record/query_cache.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   # = Active Record Query Cache
   class QueryCache
@@ -29,9 +28,10 @@ module ActiveRecord
     end
 
     def call(env)
-      enabled       = ActiveRecord::Base.connection.query_cache_enabled
+      connection    = ActiveRecord::Base.connection
+      enabled       = connection.query_cache_enabled
       connection_id = ActiveRecord::Base.connection_id
-      ActiveRecord::Base.connection.enable_query_cache!
+      connection.enable_query_cache!
 
       response = @app.call(env)
       response[2] = Rack::BodyProxy.new(response[2]) do

data/lib/active_record/querying.rb

@@ -37,15 +37,18 @@ module ActiveRecord
     #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
     def find_by_sql(sql, binds = [])
       result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds)
-      column_types = {}
+      column_types = result_set.column_types.dup
+      columns_hash.each_key { |k| column_types.delete k }
+      message_bus = ActiveSupport::Notifications.instrumenter
 
-      if result_set.respond_to? :column_types
-        column_types = result_set.column_types
-      else
-        ActiveSupport::Deprecation.warn "the object returned from `select_all` must respond to `column_types`"
-      end
+      payload = {
+        record_count: result_set.length,
+        class_name: name
+      }
 
-      result_set.map { |record| instantiate(record, column_types) }
+      message_bus.instrument('instantiation.active_record', payload) do
+        result_set.map { |record| instantiate(record, column_types) }
+      end
     end
 
     # Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part.

data/lib/active_record/railtie.rb

@@ -36,8 +36,6 @@ module ActiveRecord
     config.eager_load_namespaces << ActiveRecord
 
     rake_tasks do
-      require "active_record/base"
-
       namespace :db do
         task :load_config do
           ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
@@ -116,17 +114,22 @@ module ActiveRecord
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
       ActiveSupport.on_load(:active_record) do
+        self.configurations = Rails.application.config.database_configuration
 
-        class ActiveRecord::NoDatabaseError
-          remove_possible_method :extend_message
-          def extend_message(message)
-            message << "Run `$ bin/rake db:create db:migrate` to create your database"
-            message
-          end
-        end
+        begin
+          establish_connection
+        rescue ActiveRecord::NoDatabaseError
+          warn <<-end_warning
+Oops - You have a database configured, but it doesn't exist yet!
 
-        self.configurations = Rails.application.config.database_configuration
-        establish_connection
+Here's how to get started:
+
+  1. Configure your database in config/database.yml.
+  2. Run `bin/rake db:create` to create the database.
+  3. Run `bin/rake db:setup` to load your database schema.
+end_warning
+          raise
+        end
       end
     end
 

data/lib/active_record/railties/databases.rake

@@ -28,12 +28,20 @@ db_namespace = namespace :db do
     ActiveRecord::Tasks::DatabaseTasks.drop_current
   end
 
+  namespace :purge do
+    task :all => :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.purge_all
+    end
+  end
+
+  # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases."
+  task :purge => [:load_config] do
+    ActiveRecord::Tasks::DatabaseTasks.purge_current
+  end
+
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
   task :migrate => [:environment, :load_config] do
-    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil) do |migration|
-      ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope)
-    end
+    ActiveRecord::Tasks::DatabaseTasks.migrate
     db_namespace['_dump'].invoke if ActiveRecord::Base.dump_schema_after_migration
   end
 
@@ -82,22 +90,21 @@ db_namespace = namespace :db do
 
     desc 'Display status of migrations'
     task :status => [:environment, :load_config] do
-      unless ActiveRecord::Base.connection.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
-        puts 'Schema migrations table does not exist yet.'
-        next  # means "return" for rake task
+      unless ActiveRecord::SchemaMigration.table_exists?
+        abort 'Schema migrations table does not exist yet.'
       end
-      db_list = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name}")
-      db_list.map! { |version| "%.3d" % version }
-      file_list = []
-      ActiveRecord::Migrator.migrations_paths.each do |path|
-        Dir.foreach(path) do |file|
-          # match "20091231235959_some_name.rb" and "001_some_name.rb" pattern
-          if match_data = /^(\d{3,})_(.+)\.rb$/.match(file)
-            status = db_list.delete(match_data[1]) ? 'up' : 'down'
-            file_list << [status, match_data[1], match_data[2].humanize]
+      db_list = ActiveRecord::SchemaMigration.normalized_versions
+
+      file_list =
+          ActiveRecord::Migrator.migrations_paths.flat_map do |path|
+            # match "20091231235959_some_name.rb" and "001_some_name.rb" pattern
+            Dir.foreach(path).grep(/^(\d{3,})_(.+)\.rb$/) do
+              version = ActiveRecord::SchemaMigration.normalize_migration_number($1)
+              status = db_list.delete(version) ? 'up' : 'down'
+              [status, version, $2.humanize]
+            end
           end
-        end
-      end
+
       db_list.map! do |version|
         ['up', version, '********** NO FILE **********']
       end
@@ -105,8 +112,8 @@ db_namespace = namespace :db do
       puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
       puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
-      (db_list + file_list).sort_by {|migration| migration[1]}.each do |migration|
-        puts "#{migration[0].center(8)}  #{migration[1].ljust(14)}  #{migration[2]}"
+      (db_list + file_list).sort_by { |_, version, _| version }.each do |status, version, name|
+        puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts
     end
@@ -178,17 +185,22 @@ db_namespace = namespace :db do
     task :load => [:environment, :load_config] do
       require 'active_record/fixtures'
 
-      base_dir = if ENV['FIXTURES_PATH']
-        File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
-      else
-        ActiveRecord::Tasks::DatabaseTasks.fixtures_path
-      end
+      base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
 
-      fixtures_dir = File.join [base_dir, ENV['FIXTURES_DIR']].compact
+      fixtures_dir = if ENV['FIXTURES_DIR']
+                       File.join base_dir, ENV['FIXTURES_DIR']
+                     else
+                       base_dir
+                     end
 
-      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
-        ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, fixture_file)
-      end
+      fixture_files = if ENV['FIXTURES']
+                        ENV['FIXTURES'].split(',')
+                      else
+                        # The use of String#[] here is to support namespaced fixtures
+                        Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }
+                      end
+
+      ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, fixture_files)
     end
 
     # desc "Search for a fixture given a LABEL or ID. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
@@ -200,16 +212,11 @@ db_namespace = namespace :db do
 
       puts %Q(The fixture ID for "#{label}" is #{ActiveRecord::FixtureSet.identify(label)}.) if label
 
-      base_dir = if ENV['FIXTURES_PATH']
-        File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
-      else
-        ActiveRecord::Tasks::DatabaseTasks.fixtures_path
-      end
-
+      base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
 
       Dir["#{base_dir}/**/*.yml"].each do |file|
         if data = YAML::load(ERB.new(IO.read(file)).result)
-          data.keys.each do |key|
+          data.each_key do |key|
             key_id = ActiveRecord::FixtureSet.identify(key)
 
             if key == label || key_id == id.to_i
@@ -234,7 +241,7 @@ db_namespace = namespace :db do
 
     desc 'Load a schema.rb file into the database'
     task :load => [:environment, :load_config] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema(:ruby, ENV['SCHEMA'])
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV['SCHEMA'])
     end
 
     task :load_if_ruby => ['db:create', :environment] do
@@ -268,7 +275,8 @@ db_namespace = namespace :db do
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
 
-      if ActiveRecord::Base.connection.supports_migrations?
+      if ActiveRecord::Base.connection.supports_migrations? &&
+          ActiveRecord::SchemaMigration.table_exists?
         File.open(filename, "a") do |f|
           f.puts ActiveRecord::Base.connection.dump_schema_information
           f.print "\n"
@@ -277,9 +285,9 @@ db_namespace = namespace :db do
       db_namespace['structure:dump'].reenable
     end
 
-    # desc "Recreate the databases from the structure.sql file"
+    desc "Recreate the databases from the structure.sql file"
     task :load => [:environment, :load_config] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema(:sql, ENV['DB_STRUCTURE'])
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['DB_STRUCTURE'])
     end
 
     task :load_if_sql => ['db:create', :environment] do
@@ -297,7 +305,7 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from the current schema"
-    task :load => %w(db:test:deprecated db:test:purge) do
+    task :load => %w(db:test:purge) do
       case ActiveRecord::Base.schema_format
         when :ruby
           db_namespace["test:load_schema"].invoke
@@ -307,12 +315,11 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from an existent schema.rb file"
-    task :load_schema => %w(db:test:deprecated db:test:purge) do
+    task :load_schema => %w(db:test:purge) do
       begin
         should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
-        ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
         ActiveRecord::Schema.verbose = false
-        db_namespace["schema:load"].invoke
+        ActiveRecord::Tasks::DatabaseTasks.load_schema_for ActiveRecord::Base.configurations['test'], :ruby, ENV['SCHEMA']
       ensure
         if should_reconnect
           ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
@@ -321,13 +328,8 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from an existent structure.sql file"
-    task :load_structure => %w(db:test:deprecated db:test:purge) do
-      begin
-        ActiveRecord::Tasks::DatabaseTasks.current_config(:config => ActiveRecord::Base.configurations['test'])
-        db_namespace["structure:load"].invoke
-      ensure
-        ActiveRecord::Tasks::DatabaseTasks.current_config(:config => nil)
-      end
+    task :load_structure => %w(db:test:purge) do
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_for ActiveRecord::Base.configurations['test'], :sql, ENV['SCHEMA']
     end
 
     # desc "Recreate the test database from a fresh schema"
@@ -347,12 +349,12 @@ db_namespace = namespace :db do
     task :clone_structure => %w(db:test:deprecated db:structure:dump db:test:load_structure)
 
     # desc "Empty the test database"
-    task :purge => %w(db:test:deprecated environment load_config) do
+    task :purge => %w(environment load_config) do
       ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations['test']
     end
 
     # desc 'Check for pending migrations and load the test schema'
-    task :prepare => %w(db:test:deprecated environment load_config) do
+    task :prepare => %w(environment load_config) do
       unless ActiveRecord::Base.configurations.blank?
         db_namespace['test:load'].invoke
       end
@@ -366,7 +368,7 @@ namespace :railties do
     task :migrations => :'db:load_config' do
       to_load = ENV['FROM'].blank? ? :all : ENV['FROM'].split(",").map {|n| n.strip }
       railties = {}
-      Rails.application.railties.each do |railtie|
+      Rails.application.migration_railties.each do |railtie|
         next unless to_load == :all || to_load.include?(railtie.railtie_name)
 
         if railtie.respond_to?(:paths) && (path = railtie.paths['db/migrate'].first)

data/lib/active_record/readonly_attributes.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   module ReadonlyAttributes
     extend ActiveSupport::Concern