activerecord 5.2.5 → 6.0.0.beta1

data/lib/active_record/base.rb

@@ -9,7 +9,6 @@ require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/hash/deep_merge"
 require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/hash/transform_values"
 require "active_support/core_ext/string/behavior"
 require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/module/introspection"
@@ -23,6 +22,7 @@ require "active_record/explain_subscriber"
 require "active_record/relation/delegation"
 require "active_record/attributes"
 require "active_record/type_caster"
+require "active_record/database_configurations"
 
 module ActiveRecord #:nodoc:
   # = Active Record
@@ -289,6 +289,7 @@ module ActiveRecord #:nodoc:
     extend Enum
     extend Delegation::DelegateCache
     extend CollectionCacheKey
+    extend Aggregations::ClassMethods
 
     include Core
     include Persistence
@@ -314,7 +315,6 @@ module ActiveRecord #:nodoc:
     include ActiveModel::SecurePassword
     include AutosaveAssociation
     include NestedAttributes
-    include Aggregations
     include Transactions
     include TouchLater
     include NoTouching

data/lib/active_record/callbacks.rb

@@ -75,21 +75,7 @@ module ActiveRecord
   #   end
   #
   # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is
-  # run, both +destroy_author+ and +destroy_readers+ are called. Contrast this to the following situation
-  # where the +before_destroy+ method is overridden:
-  #
-  #   class Topic < ActiveRecord::Base
-  #     def before_destroy() destroy_author end
-  #   end
-  #
-  #   class Reply < Topic
-  #     def before_destroy() destroy_readers end
-  #   end
-  #
-  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+.
-  # So, use the callback macros when you want to ensure that a certain callback is called for the entire
-  # hierarchy, and use the regular overwritable methods when you want to leave it up to each descendant
-  # to decide whether they want to call +super+ and trigger the inherited callbacks.
+  # run, both +destroy_author+ and +destroy_readers+ are called.
   #
   # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the
   # callbacks before specifying the associations. Otherwise, you might trigger the loading of a
@@ -109,7 +95,7 @@ module ActiveRecord
   #
   #     private
   #       def delete_parents
-  #         self.class.delete_all "parent_id = #{id}"
+  #         self.class.where(parent_id: id).delete_all
   #       end
   #   end
   #
@@ -142,7 +128,7 @@ module ActiveRecord
   #       end
   #   end
   #
-  # So you specify the object you want messaged on a given callback. When that callback is triggered, the object has
+  # So you specify the object you want to be messaged on a given callback. When that callback is triggered, the object has
   # a method by the name of the callback messaged. You can make these callbacks more flexible by passing in other
   # initialization data such as the name of the attribute to work with:
   #

data/lib/active_record/collection_cache_key.rb

@@ -16,7 +16,7 @@ module ActiveRecord
           collection = collection.send(:apply_join_dependency)
         end
         column_type = type_for_attribute(timestamp_column)
-        column = connection.column_name_from_arel_node(collection.arel_attribute(timestamp_column))
+        column = connection.visitor.compile(collection.arel_attribute(timestamp_column))
         select_values = "COUNT(*) AS #{connection.quote_column_name("size")}, MAX(%s) AS timestamp"
 
         if collection.has_limit_or_offset?

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -310,7 +310,7 @@ module ActiveRecord
       include QueryCache::ConnectionPoolConfiguration
 
       attr_accessor :automatic_reconnect, :checkout_timeout, :schema_cache
-      attr_reader :spec, :size, :reaper
+      attr_reader :spec, :connections, :size, :reaper
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
       # object which describes database connection information (e.g. adapter,
@@ -379,7 +379,7 @@ module ActiveRecord
       # #connection can be called any number of times; the connection is
       # held in a cache keyed by a thread.
       def connection
-        @thread_cached_conns[connection_cache_key(current_thread)] ||= checkout
+        @thread_cached_conns[connection_cache_key(@lock_thread || Thread.current)] ||= checkout
       end
 
       # Returns true if there is an open connection being used for the current thread.
@@ -388,7 +388,7 @@ module ActiveRecord
       # #connection or #with_connection methods. Connections obtained through
       # #checkout will not be detected by #active_connection?
       def active_connection?
-        @thread_cached_conns[connection_cache_key(current_thread)]
+        @thread_cached_conns[connection_cache_key(Thread.current)]
       end
 
       # Signal that the thread is finished with the current connection.
@@ -423,21 +423,6 @@ module ActiveRecord
         synchronize { @connections.any? }
       end
 
-      # Returns an array containing the connections currently in the pool.
-      # Access to the array does not require synchronization on the pool because
-      # the array is newly created and not retained by the pool.
-      #
-      # However; this method bypasses the ConnectionPool's thread-safe connection
-      # access pattern. A returned connection may be owned by another thread,
-      # unowned, or by happen-stance owned by the calling thread.
-      #
-      # Calling methods on a connection without ownership is subject to the
-      # thread-safety guarantees of the underlying method. Many of the methods
-      # on connection adapter classes are inherently multi-thread unsafe.
-      def connections
-        synchronize { @connections.dup }
-      end
-
       # Disconnects all connections in the pool, and clears the pool.
       #
       # Raises:
@@ -683,10 +668,6 @@ module ActiveRecord
           thread
         end
 
-        def current_thread
-          @lock_thread || Thread.current
-        end
-
         # Take control of all existing connections so a "group" action such as
         # reload/disconnect can be performed safely. It is no longer enough to
         # wrap it in +synchronize+ because some pool's actions are allowed
@@ -750,7 +731,7 @@ module ActiveRecord
           # this block can't be easily moved into attempt_to_checkout_all_existing_connections's
           # rescue block, because doing so would put it outside of synchronize section, without
           # being in a critical section thread_report might become inaccurate
-          msg = "could not obtain ownership of all database connections in #{checkout_timeout} seconds".dup
+          msg = +"could not obtain ownership of all database connections in #{checkout_timeout} seconds"
 
           thread_report = []
           @connections.each do |conn|
@@ -934,16 +915,6 @@ module ActiveRecord
     # about the model. The model needs to pass a specification name to the handler,
     # in order to look up the correct connection pool.
     class ConnectionHandler
-      def self.create_owner_to_pool # :nodoc:
-        Concurrent::Map.new(initial_capacity: 2) do |h, k|
-          # Discard the parent's connection pools immediately; we have no need
-          # of them
-          discard_unowned_pools(h)
-
-          h[k] = Concurrent::Map.new(initial_capacity: 2)
-        end
-      end
-
       def self.unowned_pool_finalizer(pid_map) # :nodoc:
         lambda do |_|
           discard_unowned_pools(pid_map)
@@ -958,7 +929,13 @@ module ActiveRecord
 
       def initialize
         # These caches are keyed by spec.name (ConnectionSpecification#name).
-        @owner_to_pool = ConnectionHandler.create_owner_to_pool
+        @owner_to_pool = Concurrent::Map.new(initial_capacity: 2) do |h, k|
+          # Discard the parent's connection pools immediately; we have no need
+          # of them
+          ConnectionHandler.discard_unowned_pools(h)
+
+          h[k] = Concurrent::Map.new(initial_capacity: 2)
+        end
 
         # Backup finalizer: if the forked child never needed a pool, the above
         # early discard has not occurred
@@ -1036,8 +1013,8 @@ module ActiveRecord
       # Returns true if a connection that's accessible to this class has
       # already been opened.
       def connected?(spec_name)
-        conn = retrieve_connection_pool(spec_name)
-        conn && conn.connected?
+        pool = retrieve_connection_pool(spec_name)
+        pool && pool.connected?
       end
 
       # Remove the connection for this class. This will close the active

data/lib/active_record/connection_adapters/abstract/database_limits.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/deprecation"
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseLimits
@@ -12,11 +14,13 @@ module ActiveRecord
       def column_name_length
         64
       end
+      deprecate :column_name_length
 
       # Returns the maximum length of a table name.
       def table_name_length
         64
       end
+      deprecate :table_name_length
 
       # Returns the maximum allowed length for an index name. This
       # limit is enforced by \Rails and is less than or equal to
@@ -36,16 +40,19 @@ module ActiveRecord
       def columns_per_table
         1024
       end
+      deprecate :columns_per_table
 
       # Returns the maximum number of indexes per table.
       def indexes_per_table
         16
       end
+      deprecate :indexes_per_table
 
       # Returns the maximum number of columns in a multicolumn index.
       def columns_per_multicolumn_index
         16
       end
+      deprecate :columns_per_multicolumn_index
 
       # Returns the maximum number of elements in an IN (x,y,z) clause.
       # +nil+ means no limit.
@@ -57,11 +64,13 @@ module ActiveRecord
       def sql_query_length
         1048575
       end
+      deprecate :sql_query_length
 
       # Returns maximum number of joins in a single query.
       def joins_per_query
         256
       end
+      deprecate :joins_per_query
 
       private
         def bind_params_length

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -20,22 +20,9 @@ module ActiveRecord
             raise "Passing bind parameters with an arel AST is forbidden. " \
               "The values must be stored on the AST directly"
           end
-
-          if prepared_statements
-            sql, binds = visitor.accept(arel_or_sql_string.ast, collector).value
-
-            if binds.length > bind_params_length
-              unprepared_statement do
-                sql, binds = to_sql_and_binds(arel_or_sql_string)
-                visitor.preparable = false
-              end
-            end
-          else
-            sql = visitor.accept(arel_or_sql_string.ast, collector).value
-          end
-          [sql.freeze, binds]
+          sql, binds = visitor.compile(arel_or_sql_string.ast, collector)
+          [sql.freeze, binds || []]
         else
-          visitor.preparable = false if prepared_statements
           [arel_or_sql_string.dup.freeze, binds]
         end
       end
@@ -45,11 +32,11 @@ module ActiveRecord
       # can be used to query the database repeatedly.
       def cacheable_query(klass, arel) # :nodoc:
         if prepared_statements
-          sql, binds = visitor.accept(arel.ast, collector).value
+          sql, binds = visitor.compile(arel.ast, collector)
           query = klass.query(sql)
         else
-          collector = PartialQueryCollector.new
-          parts, binds = visitor.accept(arel.ast, collector).value
+          collector = klass.partial_query_collector
+          parts, binds = visitor.compile(arel.ast, collector)
           query = klass.partial_query(parts)
         end
         [query, binds]
@@ -60,8 +47,13 @@ module ActiveRecord
         arel = arel_from_relation(arel)
         sql, binds = to_sql_and_binds(arel, binds)
 
-        if preparable.nil?
-          preparable = prepared_statements ? visitor.preparable : false
+        if !prepared_statements || (arel.is_a?(String) && preparable.nil?)
+          preparable = false
+        elsif binds.length > bind_params_length
+          sql, binds = unprepared_statement { to_sql_and_binds(arel) }
+          preparable = false
+        else
+          preparable = visitor.preparable
         end
 
         if prepared_statements && preparable
@@ -106,6 +98,11 @@ module ActiveRecord
         exec_query(sql, name).rows
       end
 
+      # Determines whether the SQL statement is a write query.
+      def write_query?(sql)
+        raise NotImplementedError
+      end
+
       # Executes the SQL statement in the context of this connection and returns
       # the raw result from the connection adapter.
       # Note: depending on your database connector, the result returned by this
@@ -126,7 +123,7 @@ module ActiveRecord
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
-        sql, binds = sql_for_insert(sql, pk, nil, sequence_name, binds)
+        sql, binds = sql_for_insert(sql, pk, sequence_name, binds)
         exec_query(sql, name, binds)
       end
 
@@ -176,13 +173,6 @@ module ActiveRecord
         exec_delete(sql, name, binds)
       end
 
-      # Returns +true+ when the connection adapter supports prepared statement
-      # caching, otherwise returns +false+
-      def supports_statement_cache? # :nodoc:
-        true
-      end
-      deprecate :supports_statement_cache?
-
       # Runs the given block in a database transaction, and returns the result
       # of the block.
       #
@@ -272,7 +262,9 @@ module ActiveRecord
 
       attr_reader :transaction_manager #:nodoc:
 
-      delegate :within_new_transaction, :open_transactions, :current_transaction, :begin_transaction, :commit_transaction, :rollback_transaction, to: :transaction_manager
+      delegate :within_new_transaction, :open_transactions, :current_transaction, :begin_transaction,
+               :commit_transaction, :rollback_transaction, :materialize_transactions,
+               :disable_lazy_transactions!, :enable_lazy_transactions!, to: :transaction_manager
 
       def transaction_open?
         current_transaction.open?
@@ -337,7 +329,7 @@ module ActiveRecord
 
       # Inserts the given fixture into the table. Overridden in adapters that require
       # something beyond a simple insert (eg. Oracle).
-      # Most of adapters should implement `insert_fixtures` that leverages bulk SQL insert.
+      # Most of adapters should implement `insert_fixtures_set` that leverages bulk SQL insert.
       # We keep this method to provide fallback
       # for databases like sqlite that do not support bulk inserts.
       def insert_fixture(fixture, table_name)
@@ -366,18 +358,6 @@ module ActiveRecord
         execute manager.to_sql, "Fixture Insert"
       end
 
-      # Inserts a set of fixtures into the table. Overridden in adapters that require
-      # something beyond a simple insert (eg. Oracle).
-      def insert_fixtures(fixtures, table_name)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `insert_fixtures` is deprecated and will be removed in the next version of Rails.
-          Consider using `insert_fixtures_set` for performance improvement.
-        MSG
-        return if fixtures.empty?
-
-        execute(build_fixture_sql(fixtures, table_name), "Fixtures Insert")
-      end
-
       def insert_fixtures_set(fixture_set, tables_to_delete = [])
         fixture_inserts = fixture_set.map do |table_name, fixtures|
           next if fixtures.empty?
@@ -385,7 +365,7 @@ module ActiveRecord
           build_fixture_sql(fixtures, table_name)
         end.compact
 
-        table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
+        table_deletes = tables_to_delete.map { |table| +"DELETE FROM #{quote_table_name table}" }
         total_sql = Array.wrap(combine_multi_statements(table_deletes + fixture_inserts))
 
         disable_referential_integrity do
@@ -398,7 +378,7 @@ module ActiveRecord
         end
       end
 
-      def empty_insert_statement_value
+      def empty_insert_statement_value(primary_key = nil)
         "DEFAULT VALUES"
       end
 
@@ -416,16 +396,6 @@ module ActiveRecord
         end
       end
 
-      # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
-      # on MySQL (even when aliasing the tables), but MySQL allows using JOIN directly in
-      # an UPDATE statement, so in the MySQL adapters we redefine this to do that.
-      def join_to_update(update, select, key) # :nodoc:
-        subselect = subquery_for(key, select)
-
-        update.where key.in(subselect)
-      end
-      alias join_to_delete join_to_update
-
       private
         def default_insert_value(column)
           Arel.sql("DEFAULT")
@@ -466,13 +436,6 @@ module ActiveRecord
           total_sql.join(";\n")
         end
 
-        # Returns a subquery for the given key using the join information.
-        def subquery_for(key, select)
-          subselect = select.clone
-          subselect.projections = [key]
-          subselect
-        end
-
         # Returns an ActiveRecord::Result instance.
         def select(sql, name = nil, binds = [])
           exec_query(sql, name, binds, prepare: false)
@@ -482,7 +445,7 @@ module ActiveRecord
           exec_query(sql, name, binds, prepare: true)
         end
 
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        def sql_for_insert(sql, pk, sequence_name, binds)
           [sql, binds]
         end
 
@@ -513,28 +476,6 @@ module ActiveRecord
             value
           end
         end
-
-        class PartialQueryCollector
-          def initialize
-            @parts = []
-            @binds = []
-          end
-
-          def <<(str)
-            @parts << str
-            self
-          end
-
-          def add_bind(obj)
-            @binds << obj
-            @parts << Arel::Nodes::BindParam.new(1)
-            self
-          end
-
-          def value
-            [@parts, @binds]
-          end
-        end
     end
   end
 end