activerecord 4.1.16 → 4.2.11.3

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

@@ -57,8 +57,10 @@ module ActiveRecord
     console do |app|
       require "active_record/railties/console_sandbox" if app.sandbox?
       require "active_record/base"
-      console = ActiveSupport::Logger.new(STDERR)
-      Rails.logger.extend ActiveSupport::Logger.broadcast console
+      unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+        console = ActiveSupport::Logger.new(STDERR)
+        Rails.logger.extend ActiveSupport::Logger.broadcast console
+      end
     end
 
     runner do
@@ -114,17 +116,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,21 +28,32 @@ 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
-    db_namespace['_dump'].invoke if ActiveRecord::Base.dump_schema_after_migration
+    ActiveRecord::Tasks::DatabaseTasks.migrate
+    db_namespace['_dump'].invoke
   end
 
+  # IMPORTANT: This task won't dump the schema if ActiveRecord::Base.dump_schema_after_migration is set to false
   task :_dump do
-    case ActiveRecord::Base.schema_format
-    when :ruby then db_namespace["schema:dump"].invoke
-    when :sql  then db_namespace["structure:dump"].invoke
-    else
-      raise "unknown schema format #{ActiveRecord::Base.schema_format}"
+    if ActiveRecord::Base.dump_schema_after_migration
+      case ActiveRecord::Base.schema_format
+      when :ruby then db_namespace["schema:dump"].invoke
+      when :sql  then db_namespace["structure:dump"].invoke
+      else
+        raise "unknown schema format #{ActiveRecord::Base.schema_format}"
+      end
     end
     # Allow this task to be called as many times as required. An example is the
     # migrate:redo task, which calls other two internally that depend on this one.
@@ -52,6 +63,8 @@ db_namespace = namespace :db do
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => [:environment, :load_config] do
+      raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       if ENV['VERSION']
         db_namespace['migrate:down'].invoke
         db_namespace['migrate:up'].invoke
@@ -66,48 +79,34 @@ db_namespace = namespace :db do
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task :up => [:environment, :load_config] do
+      raise "VERSION is required" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
       ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
+      raise "VERSION is required - To go down one migration, use db:rollback" if ENV["VERSION"] && ENV["VERSION"].empty?
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required - To go down one migration, run db:rollback' unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
 
     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
-      end
-      db_list = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name}")
-      db_list.map! { |version| ActiveRecord::SchemaMigration.normalize_migration_number(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)
-            version = ActiveRecord::SchemaMigration.normalize_migration_number(match_data[1])
-            status = db_list.delete(version) ? 'up' : 'down'
-            file_list << [status, version, match_data[2].humanize]
-          end
-        end
-      end
-      db_list.map! do |version|
-        ['up', version, '********** NO FILE **********']
+      unless ActiveRecord::SchemaMigration.table_exists?
+        abort 'Schema migrations table does not exist yet.'
       end
+
       # output
       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]}"
+      paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+      ActiveRecord::Migrator.migrations_status(paths).each do |status, version, name|
+        puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts
     end
@@ -179,17 +178,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."
@@ -201,16 +205,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
@@ -279,8 +278,8 @@ db_namespace = namespace :db do
       db_namespace['structure:dump'].reenable
     end
 
-    # desc "Recreate the databases from the structure.sql file"
-    task :load => [:environment, :load_config] do
+    desc "Recreate the databases from the structure.sql file"
+    task :load => [:load_config] do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['DB_STRUCTURE'])
     end
 

data/lib/active_record/readonly_attributes.rb

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