activerecord 3.2.19 → 5.0.0

data/lib/active_record/query_cache.rb

@@ -1,12 +1,11 @@
-require 'active_support/core_ext/object/blank'
-
 module ActiveRecord
   # = Active Record Query Cache
   class QueryCache
     module ClassMethods
       # Enable the query cache within the block if Active Record is configured.
+      # If it's not, it will execute the given block.
       def cache(&block)
-        if ActiveRecord::Base.connected?
+        if connected?
           connection.cache(&block)
         else
           yield
@@ -14,8 +13,9 @@ module ActiveRecord
       end
 
       # Disable the query cache within the block if Active Record is configured.
+      # If it's not, it will execute the given block.
       def uncached(&block)
-        if ActiveRecord::Base.connected?
+        if connected?
           connection.uncached(&block)
         else
           yield
@@ -23,52 +23,31 @@ module ActiveRecord
       end
     end
 
-    def initialize(app)
-      @app = app
-    end
-
-    class BodyProxy # :nodoc:
-      def initialize(original_cache_value, target, connection_id)
-        @original_cache_value = original_cache_value
-        @target               = target
-        @connection_id        = connection_id
-      end
+    def self.run
+      connection    = ActiveRecord::Base.connection
+      enabled       = connection.query_cache_enabled
+      connection_id = ActiveRecord::Base.connection_id
+      connection.enable_query_cache!
 
-      def method_missing(method_sym, *arguments, &block)
-        @target.send(method_sym, *arguments, &block)
-      end
-
-      def respond_to?(method_sym, include_private = false)
-        super || @target.respond_to?(method_sym)
-      end
+      [enabled, connection_id]
+    end
 
-      def each(&block)
-        @target.each(&block)
-      end
+    def self.complete(state)
+      enabled, connection_id = state
 
-      def close
-        @target.close if @target.respond_to?(:close)
-      ensure
-        ActiveRecord::Base.connection_id = @connection_id
-        ActiveRecord::Base.connection.clear_query_cache
-        unless @original_cache_value
-          ActiveRecord::Base.connection.disable_query_cache!
-        end
-      end
+      ActiveRecord::Base.connection_id = connection_id
+      ActiveRecord::Base.connection.clear_query_cache
+      ActiveRecord::Base.connection.disable_query_cache! unless enabled
     end
 
-    def call(env)
-      old = ActiveRecord::Base.connection.query_cache_enabled
-      ActiveRecord::Base.connection.enable_query_cache!
+    def self.install_executor_hooks(executor = ActiveSupport::Executor)
+      executor.register_hook(self)
 
-      status, headers, body = @app.call(env)
-      [status, headers, BodyProxy.new(old, body, ActiveRecord::Base.connection_id)]
-    rescue Exception => e
-      ActiveRecord::Base.connection.clear_query_cache
-      unless old
-        ActiveRecord::Base.connection.disable_query_cache!
+      executor.to_complete do
+        unless ActiveRecord::Base.connection.transaction_open?
+          ActiveRecord::Base.clear_active_connections!
+        end
       end
-      raise e
     end
   end
 end

data/lib/active_record/querying.rb

@@ -1,20 +1,22 @@
-require 'active_support/core_ext/module/delegation'
-
 module ActiveRecord
   module Querying
-    delegate :find, :first, :first!, :last, :last!, :all, :exists?, :any?, :many?, :to => :scoped
-    delegate :first_or_create, :first_or_create!, :first_or_initialize, :to => :scoped
-    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, :to => :scoped
-    delegate :find_each, :find_in_batches, :to => :scoped
-    delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins,
-             :where, :preload, :eager_load, :includes, :from, :lock, :readonly,
-             :having, :create_with, :uniq, :to => :scoped
-    delegate :count, :average, :minimum, :maximum, :sum, :calculate, :pluck, :to => :scoped
+    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :none?, :one?, to: :all
+    delegate :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!, :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!, to: :all
+    delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
+    delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, to: :all
+    delegate :find_by, :find_by!, to: :all
+    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, to: :all
+    delegate :find_each, :find_in_batches, :in_batches, to: :all
+    delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins, :left_joins, :left_outer_joins, :or,
+             :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly,
+             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, to: :all
+    delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
+    delegate :pluck, :ids, to: :all
 
     # Executes a custom SQL query against your database and returns all the results. The results will
     # be returned as an array with columns requested encapsulated as attributes of the model you call
     # this method from. If you call <tt>Product.find_by_sql</tt> then the results will be returned in
-    # a Product object with the attributes you specified in the SQL query.
+    # a +Product+ object with the attributes you specified in the SQL query.
     #
     # If you call a complicated SQL query which spans multiple tables the columns specified by the
     # SELECT will be attributes of the model, whether or not they are columns of the corresponding
@@ -25,17 +27,27 @@ module ActiveRecord
     # MySQL specific terms will lock you to using that particular database engine or require you to
     # change your call if you switch engines.
     #
-    # ==== Examples
     #   # A simple SQL query spanning multiple tables
     #   Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
-    #   > [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
+    #   # => [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
+    #
+    # You can use the same string replacement techniques as you can with <tt>ActiveRecord::QueryMethods#where</tt>:
     #
-    #   # You can use the same string replacement techniques as you can with ActiveRecord#find
     #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
-    #   > [#<Post:0x36bff9c @attributes={"title"=>"The Cheap Man Buys Twice"}>, ...]
-    def find_by_sql(sql, binds = [])
-      logging_query_plan do
-        connection.select_all(sanitize_sql(sql), "#{name} Load", binds).collect! { |record| instantiate(record) }
+    #   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 = [], preparable: nil)
+      result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
+      column_types = result_set.column_types.dup
+      columns_hash.each_key { |k| column_types.delete k }
+      message_bus = ActiveSupport::Notifications.instrumenter
+
+      payload = {
+        record_count: result_set.length,
+        class_name: name
+      }
+
+      message_bus.instrument('instantiation.active_record', payload) do
+        result_set.map { |record| instantiate(record, column_types) }
       end
     end
 
@@ -43,13 +55,12 @@ module ActiveRecord
     # The use of this method should be restricted to complicated SQL queries that can't be executed
     # using the ActiveRecord::Calculations class methods. Look into those before using this.
     #
-    # ==== Parameters
-    #
-    # * +sql+ - An SQL statement which should return a count query from the database, see the example below.
+    #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
+    #   # => 12
     #
-    # ==== Examples
+    # ==== Parameters
     #
-    #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
+    # * +sql+ - An SQL statement which should return a count query from the database, see the example above.
     def count_by_sql(sql)
       sql = sanitize_conditions(sql)
       connection.select_value(sql, "#{name} Count").to_i

data/lib/active_record/railtie.rb

@@ -10,18 +10,12 @@ require "action_controller/railtie"
 
 module ActiveRecord
   # = Active Record Railtie
-  class Railtie < Rails::Railtie
+  class Railtie < Rails::Railtie # :nodoc:
     config.active_record = ActiveSupport::OrderedOptions.new
 
     config.app_generators.orm :active_record, :migration => true,
                                               :timestamps => true
 
-    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
-      "ActiveRecord::QueryCache"
-
-    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
-      "ActiveRecord::ConnectionAdapters::ConnectionManagement"
-
     config.action_dispatch.rescue_responses.merge!(
       'ActiveRecord::RecordNotFound'   => :not_found,
       'ActiveRecord::StaleObjectError' => :conflict,
@@ -29,8 +23,25 @@ module ActiveRecord
       'ActiveRecord::RecordNotSaved'   => :unprocessable_entity
     )
 
+
+    config.active_record.use_schema_cache_dump = true
+    config.active_record.maintain_test_schema = true
+
+    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
+
+          if defined?(ENGINE_ROOT) && engine = Rails::Engine.find(ENGINE_ROOT)
+            if engine.paths['db/migrate'].existent
+              ActiveRecord::Tasks::DatabaseTasks.migrations_paths += engine.paths['db/migrate'].to_a
+            end
+          end
+        end
+      end
+
       load "active_record/railties/databases.rake"
     end
 
@@ -40,10 +51,13 @@ module ActiveRecord
     console do |app|
       require "active_record/railties/console_sandbox" if app.sandbox?
       require "active_record/base"
-      ActiveRecord::Base.logger = Logger.new(STDERR)
+      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 |app|
+    runner do
       require "active_record/base"
     end
 
@@ -58,16 +72,43 @@ module ActiveRecord
       ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
     end
 
-    initializer "active_record.identity_map" do |app|
-      config.app_middleware.insert_after "::ActionDispatch::Callbacks",
-        "ActiveRecord::IdentityMap::Middleware" if config.active_record.delete(:identity_map)
+    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
+      end
+    end
+
+    initializer "active_record.check_schema_cache_dump" do
+      if config.active_record.delete(:use_schema_cache_dump)
+        config.after_initialize do |app|
+          ActiveSupport.on_load(:active_record) do
+            filename = File.join(app.config.paths["db"].first, "schema_cache.dump")
+
+            if File.file?(filename)
+              cache = Marshal.load File.binread filename
+              if cache.version == ActiveRecord::Migrator.current_version
+                self.connection.schema_cache = cache
+                self.connection_pool.schema_cache = cache.dup
+              else
+                warn "Ignoring db/schema_cache.dump because it has expired. The current schema version is #{ActiveRecord::Migrator.current_version}, but the one in the cache is #{cache.version}."
+              end
+            end
+          end
+        end
+      end
+    end
+
+    initializer "active_record.warn_on_records_fetched_greater_than" do
+      if config.active_record.warn_on_records_fetched_greater_than
+        ActiveSupport.on_load(:active_record) do
+          require 'active_record/relation/record_fetch_warning'
+        end
+      end
     end
 
     initializer "active_record.set_configs" do |app|
       ActiveSupport.on_load(:active_record) do
-        if app.config.active_record.delete(:whitelist_attributes)
-          attr_accessible(nil)
-        end
         app.config.active_record.each do |k,v|
           send "#{k}=", v
         end
@@ -76,56 +117,55 @@ module ActiveRecord
 
     # This sets the database configuration from Configuration#database_configuration
     # and then establishes the connection.
-    initializer "active_record.initialize_database" do |app|
+    initializer "active_record.initialize_database" do
       ActiveSupport.on_load(:active_record) do
-        db_connection_type = "DATABASE_URL"
-        unless ENV['DATABASE_URL']
-          db_connection_type  = "database.yml"
-          self.configurations = app.config.database_configuration
-        end
-        Rails.logger.info "Connecting to database specified by #{db_connection_type}"
+        self.configurations = Rails.application.config.database_configuration
+
+        begin
+          establish_connection
+        rescue ActiveRecord::NoDatabaseError
+          warn <<-end_warning
+Oops - You have a database configured, but it doesn't exist yet!
 
-        establish_connection
+Here's how to get started:
+
+  1. Configure your database in config/database.yml.
+  2. Run `bin/rails db:create` to create the database.
+  3. Run `bin/rails db:setup` to load your database schema.
+end_warning
+          raise
+        end
       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
       end
     end
 
-    initializer "active_record.set_reloader_hooks" do |app|
-      hook = lambda do
-        ActiveRecord::Base.clear_reloadable_connections!
-        ActiveRecord::Base.clear_cache!
-      end
-
-      if app.config.reload_classes_only_on_change
-        ActiveSupport.on_load(:active_record) do
-          ActionDispatch::Reloader.to_prepare(&hook)
-        end
-      else
-        ActiveSupport.on_load(:active_record) do
-          ActionDispatch::Reloader.to_cleanup(&hook)
+    initializer "active_record.set_reloader_hooks" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveSupport::Reloader.before_class_unload do
+          if ActiveRecord::Base.connected?
+            ActiveRecord::Base.clear_cache!
+            ActiveRecord::Base.clear_reloadable_connections!
+          end
         end
       end
     end
 
-    initializer "active_record.add_watchable_files" do |app|
-      config.watchable_files.concat ["#{app.root}/db/schema.rb", "#{app.root}/db/structure.sql"]
-    end
-
-    config.after_initialize do
+    initializer "active_record.set_executor_hooks" do
       ActiveSupport.on_load(:active_record) do
-        instantiate_observers
-
-        ActionDispatch::Reloader.to_prepare do
-          ActiveRecord::Base.instantiate_observers
-        end
+        ActiveRecord::QueryCache.install_executor_hooks
       end
     end
+
+    initializer "active_record.add_watchable_files" do |app|
+      path = app.paths["db"].first
+      config.watchable_files.concat ["#{path}/schema.rb", "#{path}/structure.sql"]
+    end
   end
 end

data/lib/active_record/railties/console_sandbox.rb

@@ -1,6 +1,5 @@
-ActiveRecord::Base.connection.increment_open_transactions
-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.decrement_open_transactions
+  ActiveRecord::Base.connection.rollback_transaction
 end

data/lib/active_record/railties/controller_runtime.rb

@@ -2,7 +2,7 @@ require 'active_support/core_ext/module/attr_internal'
 require 'active_record/log_subscriber'
 
 module ActiveRecord
-  module Railties
+  module Railties # :nodoc:
     module ControllerRuntime #:nodoc:
       extend ActiveSupport::Concern
 
@@ -19,11 +19,12 @@ module ActiveRecord
       end
 
       def cleanup_view_runtime
-        if ActiveRecord::Base.connected?
+        if logger.info? && 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
@@ -37,7 +38,7 @@ module ActiveRecord
         end
       end
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         def log_process_action(payload)
           messages, db_runtime = super, payload[:db_runtime]
           messages << ("ActiveRecord: %.1fms" % db_runtime.to_f) if db_runtime