activerecord 6.0.0.beta1 → 6.0.0

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

@@ -3,6 +3,7 @@
 require "thread"
 require "concurrent/map"
 require "monitor"
+require "weakref"
 
 module ActiveRecord
   # Raised when a connection could not be obtained within the connection
@@ -19,6 +20,26 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
+    module AbstractPool # :nodoc:
+      def get_schema_cache(connection)
+        @schema_cache ||= SchemaCache.new(connection)
+        @schema_cache.connection = connection
+        @schema_cache
+      end
+
+      def set_schema_cache(cache)
+        @schema_cache = cache
+      end
+    end
+
+    class NullPool # :nodoc:
+      include ConnectionAdapters::AbstractPool
+
+      def initialize
+        @schema_cache = nil
+      end
+    end
+
     # Connection pool base class for managing Active Record database
     # connections.
     #
@@ -185,7 +206,7 @@ module ActiveRecord
           def wait_poll(timeout)
             @num_waiting += 1
 
-            t0 = Time.now
+            t0 = Concurrent.monotonic_time
             elapsed = 0
             loop do
               ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
@@ -194,7 +215,7 @@ module ActiveRecord
 
               return remove if any?
 
-              elapsed = Time.now - t0
+              elapsed = Concurrent.monotonic_time - t0
               if elapsed >= timeout
                 msg = "could not obtain a connection from the pool within %0.3f seconds (waited %0.3f seconds); all pooled connections were in use" %
                   [timeout, elapsed]
@@ -294,23 +315,51 @@ module ActiveRecord
           @frequency = frequency
         end
 
+        @mutex = Mutex.new
+        @pools = {}
+
+        class << self
+          def register_pool(pool, frequency) # :nodoc:
+            @mutex.synchronize do
+              unless @pools.key?(frequency)
+                @pools[frequency] = []
+                spawn_thread(frequency)
+              end
+              @pools[frequency] << WeakRef.new(pool)
+            end
+          end
+
+          private
+
+            def spawn_thread(frequency)
+              Thread.new(frequency) do |t|
+                loop do
+                  sleep t
+                  @mutex.synchronize do
+                    @pools[frequency].select!(&:weakref_alive?)
+                    @pools[frequency].each do |p|
+                      p.reap
+                      p.flush
+                    rescue WeakRef::RefError
+                    end
+                  end
+                end
+              end
+            end
+        end
+
         def run
           return unless frequency && frequency > 0
-          Thread.new(frequency, pool) { |t, p|
-            loop do
-              sleep t
-              p.reap
-              p.flush
-            end
-          }
+          self.class.register_pool(pool, frequency)
         end
       end
 
       include MonitorMixin
       include QueryCache::ConnectionPoolConfiguration
+      include ConnectionAdapters::AbstractPool
 
       attr_accessor :automatic_reconnect, :checkout_timeout, :schema_cache
-      attr_reader :spec, :connections, :size, :reaper
+      attr_reader :spec, :size, :reaper
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
       # object which describes database connection information (e.g. adapter,
@@ -379,7 +428,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(@lock_thread || Thread.current)] ||= checkout
+        @thread_cached_conns[connection_cache_key(current_thread)] ||= checkout
       end
 
       # Returns true if there is an open connection being used for the current thread.
@@ -388,7 +437,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(Thread.current)]
+        @thread_cached_conns[connection_cache_key(current_thread)]
       end
 
       # Signal that the thread is finished with the current connection.
@@ -423,6 +472,21 @@ 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:
@@ -668,6 +732,10 @@ 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
@@ -686,13 +754,13 @@ module ActiveRecord
           end
 
           newly_checked_out = []
-          timeout_time      = Time.now + (@checkout_timeout * 2)
+          timeout_time      = Concurrent.monotonic_time + (@checkout_timeout * 2)
 
           @available.with_a_bias_for(Thread.current) do
             loop do
               synchronize do
                 return if collected_conns.size == @connections.size && @now_connecting == 0
-                remaining_timeout = timeout_time - Time.now
+                remaining_timeout = timeout_time - Concurrent.monotonic_time
                 remaining_timeout = 0 if remaining_timeout < 0
                 conn = checkout_for_exclusive_access(remaining_timeout)
                 collected_conns   << conn
@@ -809,7 +877,7 @@ module ActiveRecord
 
         def new_connection
           Base.send(spec.adapter_method, spec.config).tap do |conn|
-            conn.schema_cache = schema_cache.dup if schema_cache
+            conn.check_version
           end
         end
 
@@ -915,6 +983,16 @@ 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)
@@ -929,19 +1007,33 @@ module ActiveRecord
 
       def initialize
         # These caches are keyed by spec.name (ConnectionSpecification#name).
-        @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
+        @owner_to_pool = ConnectionHandler.create_owner_to_pool
 
         # Backup finalizer: if the forked child never needed a pool, the above
         # early discard has not occurred
         ObjectSpace.define_finalizer self, ConnectionHandler.unowned_pool_finalizer(@owner_to_pool)
       end
 
+      def prevent_writes # :nodoc:
+        Thread.current[:prevent_writes]
+      end
+
+      def prevent_writes=(prevent_writes) # :nodoc:
+        Thread.current[:prevent_writes] = prevent_writes
+      end
+
+      # Prevent writing to the database regardless of role.
+      #
+      # In some cases you may want to prevent writes to the database
+      # even if you are on a database that can write. `while_preventing_writes`
+      # will prevent writes to the database for the duration of the block.
+      def while_preventing_writes(enabled = true)
+        original, self.prevent_writes = self.prevent_writes, enabled
+        yield
+      ensure
+        self.prevent_writes = original
+      end
+
       def connection_pool_list
         owner_to_pool.values.compact
       end
@@ -1006,7 +1098,16 @@ module ActiveRecord
       # for (not necessarily the current class).
       def retrieve_connection(spec_name) #:nodoc:
         pool = retrieve_connection_pool(spec_name)
-        raise ConnectionNotEstablished, "No connection pool with '#{spec_name}' found." unless pool
+
+        unless pool
+          # multiple database application
+          if ActiveRecord::Base.connection_handler != ActiveRecord::Base.default_connection_handler
+            raise ConnectionNotEstablished, "No connection pool with '#{spec_name}' found for the '#{ActiveRecord::Base.current_role}' role."
+          else
+            raise ConnectionNotEstablished, "No connection pool with '#{spec_name}' found."
+          end
+        end
+
         pool.connection
       end
 

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

@@ -5,20 +5,24 @@ require "active_support/deprecation"
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseLimits
+      def max_identifier_length # :nodoc:
+        64
+      end
+
       # Returns the maximum length of a table alias.
       def table_alias_length
-        255
+        max_identifier_length
       end
 
       # Returns the maximum length of a column name.
       def column_name_length
-        64
+        max_identifier_length
       end
       deprecate :column_name_length
 
       # Returns the maximum length of a table name.
       def table_name_length
-        64
+        max_identifier_length
       end
       deprecate :table_name_length
 
@@ -33,7 +37,7 @@ module ActiveRecord
 
       # Returns the maximum length of an index name.
       def index_name_length
-        64
+        max_identifier_length
       end
 
       # Returns the maximum number of columns per table.

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

@@ -20,9 +20,22 @@ module ActiveRecord
             raise "Passing bind parameters with an arel AST is forbidden. " \
               "The values must be stored on the AST directly"
           end
-          sql, binds = visitor.compile(arel_or_sql_string.ast, collector)
-          [sql.freeze, binds || []]
+
+          if prepared_statements
+            sql, binds = visitor.compile(arel_or_sql_string.ast, collector)
+
+            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.compile(arel_or_sql_string.ast, collector)
+          end
+          [sql.freeze, binds]
         else
+          visitor.preparable = false if prepared_statements
           [arel_or_sql_string.dup.freeze, binds]
         end
       end
@@ -47,13 +60,8 @@ module ActiveRecord
         arel = arel_from_relation(arel)
         sql, binds = to_sql_and_binds(arel, binds)
 
-        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
+        if preparable.nil?
+          preparable = prepared_statements ? visitor.preparable : false
         end
 
         if prepared_statements && preparable
@@ -123,7 +131,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, sequence_name, binds)
+        sql, binds = sql_for_insert(sql, pk, binds)
         exec_query(sql, name, binds)
       end
 
@@ -134,11 +142,6 @@ module ActiveRecord
         exec_query(sql, name, binds)
       end
 
-      # Executes the truncate statement.
-      def truncate(table_name, name = nil)
-        raise NotImplementedError
-      end
-
       # Executes update +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
@@ -173,6 +176,23 @@ module ActiveRecord
         exec_delete(sql, name, binds)
       end
 
+      # Executes the truncate statement.
+      def truncate(table_name, name = nil)
+        execute(build_truncate_statements(table_name), name)
+      end
+
+      def truncate_tables(*table_names) # :nodoc:
+        return if table_names.empty?
+
+        with_multi_statements do
+          disable_referential_integrity do
+            Array(build_truncate_statements(*table_names)).each do |sql|
+              execute_batch(sql, "Truncate Tables")
+            end
+          end
+        end
+      end
+
       # Runs the given block in a database transaction, and returns the result
       # of the block.
       #
@@ -333,46 +353,20 @@ module ActiveRecord
       # We keep this method to provide fallback
       # for databases like sqlite that do not support bulk inserts.
       def insert_fixture(fixture, table_name)
-        fixture = fixture.stringify_keys
-
-        columns = schema_cache.columns_hash(table_name)
-        binds = fixture.map do |name, value|
-          if column = columns[name]
-            type = lookup_cast_type_from_column(column)
-            Relation::QueryAttribute.new(name, value, type)
-          else
-            raise Fixture::FixtureError, %(table "#{table_name}" has no column named #{name.inspect}.)
-          end
-        end
-
-        table = Arel::Table.new(table_name)
-
-        values = binds.map do |bind|
-          value = with_yaml_fallback(bind.value_for_database)
-          [table[bind.name], value]
-        end
-
-        manager = Arel::InsertManager.new
-        manager.into(table)
-        manager.insert(values)
-        execute manager.to_sql, "Fixture Insert"
+        execute(build_fixture_sql(Array.wrap(fixture), table_name), "Fixture Insert")
       end
 
       def insert_fixtures_set(fixture_set, tables_to_delete = [])
-        fixture_inserts = fixture_set.map do |table_name, fixtures|
-          next if fixtures.empty?
-
-          build_fixture_sql(fixtures, table_name)
-        end.compact
-
-        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
-          transaction(requires_new: true) do
-            total_sql.each do |sql|
-              execute sql, "Fixtures Load"
-              yield if block_given?
+        fixture_inserts = build_fixture_statements(fixture_set)
+        table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name(table)}" }
+        total_sql = Array(combine_multi_statements(table_deletes + fixture_inserts))
+
+        with_multi_statements do
+          disable_referential_integrity do
+            transaction(requires_new: true) do
+              total_sql.each do |sql|
+                execute_batch(sql, "Fixtures Load")
+              end
             end
           end
         end
@@ -396,15 +390,33 @@ module ActiveRecord
         end
       end
 
+      # Fixture value is quoted by Arel, however scalar values
+      # are not quotable. In this case we want to convert
+      # the column value to YAML.
+      def with_yaml_fallback(value) # :nodoc:
+        if value.is_a?(Hash) || value.is_a?(Array)
+          YAML.dump(value)
+        else
+          value
+        end
+      end
+
       private
+        def execute_batch(sql, name = nil)
+          execute(sql, name)
+        end
+
+        DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
+        private_constant :DEFAULT_INSERT_VALUE
+
         def default_insert_value(column)
-          Arel.sql("DEFAULT")
+          DEFAULT_INSERT_VALUE
         end
 
         def build_fixture_sql(fixtures, table_name)
           columns = schema_cache.columns_hash(table_name)
 
-          values = fixtures.map do |fixture|
+          values_list = fixtures.map do |fixture|
             fixture = fixture.stringify_keys
 
             unknown_columns = fixture.keys - columns.keys
@@ -415,8 +427,7 @@ module ActiveRecord
             columns.map do |name, column|
               if fixture.key?(name)
                 type = lookup_cast_type_from_column(column)
-                bind = Relation::QueryAttribute.new(name, fixture[name], type)
-                with_yaml_fallback(bind.value_for_database)
+                with_yaml_fallback(type.serialize(fixture[name]))
               else
                 default_insert_value(column)
               end
@@ -426,12 +437,43 @@ module ActiveRecord
           table = Arel::Table.new(table_name)
           manager = Arel::InsertManager.new
           manager.into(table)
-          columns.each_key { |column| manager.columns << table[column] }
-          manager.values = manager.create_values_list(values)
 
+          if values_list.size == 1
+            values = values_list.shift
+            new_values = []
+            columns.each_key.with_index { |column, i|
+              unless values[i].equal?(DEFAULT_INSERT_VALUE)
+                new_values << values[i]
+                manager.columns << table[column]
+              end
+            }
+            values_list << new_values
+          else
+            columns.each_key { |column| manager.columns << table[column] }
+          end
+
+          manager.values = manager.create_values_list(values_list)
           manager.to_sql
         end
 
+        def build_fixture_statements(fixture_set)
+          fixture_set.map do |table_name, fixtures|
+            next if fixtures.empty?
+            build_fixture_sql(fixtures, table_name)
+          end.compact
+        end
+
+        def build_truncate_statements(*table_names)
+          truncate_tables = table_names.map do |table_name|
+            "TRUNCATE TABLE #{quote_table_name(table_name)}"
+          end
+          combine_multi_statements(truncate_tables)
+        end
+
+        def with_multi_statements
+          yield
+        end
+
         def combine_multi_statements(total_sql)
           total_sql.join(";\n")
         end
@@ -445,7 +487,7 @@ module ActiveRecord
           exec_query(sql, name, binds, prepare: true)
         end
 
-        def sql_for_insert(sql, pk, sequence_name, binds)
+        def sql_for_insert(sql, pk, binds)
           [sql, binds]
         end
 
@@ -465,17 +507,6 @@ module ActiveRecord
             relation
           end
         end
-
-        # Fixture value is quoted by Arel, however scalar values
-        # are not quotable. In this case we want to convert
-        # the column value to YAML.
-        def with_yaml_fallback(value)
-          if value.is_a?(Hash) || value.is_a?(Array)
-            YAML.dump(value)
-          else
-            value
-          end
-        end
     end
   end
 end

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

@@ -7,7 +7,8 @@ module ActiveRecord
     module QueryCache
       class << self
         def included(base) #:nodoc:
-          dirties_query_cache base, :insert, :update, :delete, :rollback_to_savepoint, :rollback_db_transaction
+          dirties_query_cache base, :insert, :update, :delete, :truncate, :truncate_tables,
+            :rollback_to_savepoint, :rollback_db_transaction
 
           base.set_callback :checkout, :after, :configure_query_cache!
           base.set_callback :checkin, :after, :disable_query_cache!
@@ -17,7 +18,7 @@ module ActiveRecord
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
               def #{method_name}(*)
-                clear_query_cache if @query_cache_enabled
+                ActiveRecord::Base.clear_query_caches_for_current_thread if @query_cache_enabled
                 super
               end
             end_code
@@ -32,17 +33,17 @@ module ActiveRecord
         end
 
         def enable_query_cache!
-          @query_cache_enabled[connection_cache_key(Thread.current)] = true
+          @query_cache_enabled[connection_cache_key(current_thread)] = true
           connection.enable_query_cache! if active_connection?
         end
 
         def disable_query_cache!
-          @query_cache_enabled.delete connection_cache_key(Thread.current)
+          @query_cache_enabled.delete connection_cache_key(current_thread)
           connection.disable_query_cache! if active_connection?
         end
 
         def query_cache_enabled
-          @query_cache_enabled[connection_cache_key(Thread.current)]
+          @query_cache_enabled[connection_cache_key(current_thread)]
         end
       end
 
@@ -96,6 +97,11 @@ module ActiveRecord
         if @query_cache_enabled && !locked?(arel)
           arel = arel_from_relation(arel)
           sql, binds = to_sql_and_binds(arel, binds)
+
+          if preparable.nil?
+            preparable = prepared_statements ? visitor.preparable : false
+          end
+
           cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable) }
         else
           super

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

@@ -138,15 +138,72 @@ module ActiveRecord
         "'#{quote_string(value.to_s)}'"
       end
 
-      def type_casted_binds(binds) # :nodoc:
-        if binds.first.is_a?(Array)
-          binds.map { |column, value| type_cast(value, column) }
-        else
-          binds.map { |attr| type_cast(attr.value_for_database) }
-        end
+      def sanitize_as_sql_comment(value) # :nodoc:
+        value.to_s.gsub(%r{ (/ (?: | \g<1>) \*) \+? \s* | \s* (\* (?: | \g<2>) /) }x, "")
+      end
+
+      def column_name_matcher # :nodoc:
+        COLUMN_NAME
+      end
+
+      def column_name_with_order_matcher # :nodoc:
+        COLUMN_NAME_WITH_ORDER
       end
 
+      # Regexp for column names (with or without a table name prefix).
+      # Matches the following:
+      #
+      #   "#{table_name}.#{column_name}"
+      #   "#{column_name}"
+      COLUMN_NAME = /
+        \A
+        (
+          (?:
+            # table_name.column_name | function(one or no argument)
+            ((?:\w+\.)?\w+) | \w+\((?:|\g<2>)\)
+          )
+          (?:\s+AS\s+\w+)?
+        )
+        (?:\s*,\s*\g<1>)*
+        \z
+      /ix
+
+      # Regexp for column names with order (with or without a table name prefix,
+      # with or without various order modifiers). Matches the following:
+      #
+      #   "#{table_name}.#{column_name}"
+      #   "#{table_name}.#{column_name} #{direction}"
+      #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
+      #   "#{table_name}.#{column_name} NULLS LAST"
+      #   "#{column_name}"
+      #   "#{column_name} #{direction}"
+      #   "#{column_name} #{direction} NULLS FIRST"
+      #   "#{column_name} NULLS LAST"
+      COLUMN_NAME_WITH_ORDER = /
+        \A
+        (
+          (?:
+            # table_name.column_name | function(one or no argument)
+            ((?:\w+\.)?\w+) | \w+\((?:|\g<2>)\)
+          )
+          (?:\s+ASC|\s+DESC)?
+          (?:\s+NULLS\s+(?:FIRST|LAST))?
+        )
+        (?:\s*,\s*\g<1>)*
+        \z
+      /ix
+
+      private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
       private
+        def type_casted_binds(binds)
+          if binds.first.is_a?(Array)
+            binds.map { |column, value| type_cast(value, column) }
+          else
+            binds.map { |attr| type_cast(attr.value_for_database) }
+          end
+        end
+
         def lookup_cast_type(sql_type)
           type_map.lookup(sql_type)
         end