activerecord 6.1.4 → 7.0.0.rc1

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

@@ -59,17 +59,13 @@ module ActiveRecord
       end
 
       # Returns an ActiveRecord::Result instance.
-      def select_all(arel, name = nil, binds = [], preparable: nil)
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false)
         arel = arel_from_relation(arel)
         sql, binds, preparable = to_sql_and_binds(arel, binds, preparable)
 
-        if prepared_statements && preparable
-          select_prepared(sql, name, binds)
-        else
-          select(sql, name, binds)
-        end
+        select(sql, name, binds, prepare: prepared_statements && preparable, async: async && FutureResult::SelectAll)
       rescue ::RangeError
-        ActiveRecord::Result.new([], [])
+        ActiveRecord::Result.empty
       end
 
       # Returns a record hash with the column names as keys and column values
@@ -310,20 +306,20 @@ module ActiveRecord
       #
       # The mysql2 and postgresql adapters support setting the transaction
       # isolation level.
-      def transaction(requires_new: nil, isolation: nil, joinable: true)
+      def transaction(requires_new: nil, isolation: nil, joinable: true, &block)
         if !requires_new && current_transaction.joinable?
           if isolation
             raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
           end
           yield
         else
-          transaction_manager.within_new_transaction(isolation: isolation, joinable: joinable) { yield }
+          transaction_manager.within_new_transaction(isolation: isolation, joinable: joinable, &block)
         end
       rescue ActiveRecord::Rollback
         # rollbacks are silently swallowed
       end
 
-      attr_reader :transaction_manager #:nodoc:
+      attr_reader :transaction_manager # :nodoc:
 
       delegate :within_new_transaction, :open_transactions, :current_transaction, :begin_transaction,
                :commit_transaction, :rollback_transaction, :materialize_transactions,
@@ -340,7 +336,7 @@ module ActiveRecord
         current_transaction.open?
       end
 
-      def reset_transaction #:nodoc:
+      def reset_transaction # :nodoc:
         @transaction_manager = ConnectionAdapters::TransactionManager.new(self)
       end
 
@@ -378,7 +374,7 @@ module ActiveRecord
         exec_rollback_db_transaction
       end
 
-      def exec_rollback_db_transaction() end #:nodoc:
+      def exec_rollback_db_transaction() end # :nodoc:
 
       def rollback_to_savepoint(name = nil)
         exec_rollback_to_savepoint(name)
@@ -445,6 +441,19 @@ module ActiveRecord
         end
       end
 
+      # This is a safe default, even if not high precision on all databases
+      HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP").freeze # :nodoc:
+      private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+      # Returns an Arel SQL literal for the CURRENT_TIMESTAMP for usage with
+      # arbitrary precision date/time columns.
+      #
+      # Adapters supporting datetime with precision should override this to
+      # provide as much precision as is available.
+      def high_precision_current_timestamp
+        HIGH_PRECISION_CURRENT_TIMESTAMP
+      end
+
       private
         def execute_batch(statements, name = nil)
           statements.each do |statement|
@@ -460,7 +469,7 @@ module ActiveRecord
         end
 
         def build_fixture_sql(fixtures, table_name)
-          columns = schema_cache.columns_hash(table_name)
+          columns = schema_cache.columns_hash(table_name).reject { |_, column| supports_virtual_columns? && column.virtual? }
 
           values_list = fixtures.map do |fixture|
             fixture = fixture.stringify_keys
@@ -481,8 +490,7 @@ module ActiveRecord
           end
 
           table = Arel::Table.new(table_name)
-          manager = Arel::InsertManager.new
-          manager.into(table)
+          manager = Arel::InsertManager.new(table)
 
           if values_list.size == 1
             values = values_list.shift
@@ -503,10 +511,10 @@ module ActiveRecord
         end
 
         def build_fixture_statements(fixture_set)
-          fixture_set.map do |table_name, fixtures|
+          fixture_set.filter_map do |table_name, fixtures|
             next if fixtures.empty?
             build_fixture_sql(fixtures, table_name)
-          end.compact
+          end
         end
 
         def build_truncate_statement(table_name)
@@ -528,12 +536,28 @@ module ActiveRecord
         end
 
         # Returns an ActiveRecord::Result instance.
-        def select(sql, name = nil, binds = [])
-          exec_query(sql, name, binds, prepare: false)
-        end
+        def select(sql, name = nil, binds = [], prepare: false, async: false)
+          if async && async_enabled?
+            if current_transaction.joinable?
+              raise AsynchronousQueryInsideTransactionError, "Asynchronous queries are not allowed inside transactions"
+            end
+
+            future_result = async.new(
+              pool,
+              sql,
+              name,
+              binds,
+              prepare: prepare,
+            )
+            if supports_concurrent_connections? && current_transaction.closed?
+              future_result.schedule!(ActiveRecord::Base.asynchronous_queries_session)
+            else
+              future_result.execute!(self)
+            end
+            return future_result
+          end
 
-        def select_prepared(sql, name = nil, binds = [])
-          exec_query(sql, name, binds, prepare: true)
+          exec_query(sql, name, binds, prepare: prepare)
         end
 
         def sql_for_insert(sql, pk, binds)

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

@@ -6,7 +6,7 @@ module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module QueryCache
       class << self
-        def included(base) #:nodoc:
+        def included(base) # :nodoc:
           dirties_query_cache base, :create, :insert, :update, :delete, :truncate, :truncate_tables,
             :rollback_to_savepoint, :rollback_db_transaction, :exec_insert_all
 
@@ -93,18 +93,37 @@ module ActiveRecord
         end
       end
 
-      def select_all(arel, name = nil, binds = [], preparable: nil)
-        if @query_cache_enabled && !locked?(arel)
-          arel = arel_from_relation(arel)
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false)
+        arel = arel_from_relation(arel)
+
+        # If arel is locked this is a SELECT ... FOR UPDATE or somesuch.
+        # Such queries should not be cached.
+        if @query_cache_enabled && !(arel.respond_to?(:locked) && arel.locked)
           sql, binds, preparable = to_sql_and_binds(arel, binds, preparable)
 
-          cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable) }
+          if async
+            lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async)
+          else
+            cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable, async: async) }
+          end
         else
           super
         end
       end
 
       private
+        def lookup_sql_cache(sql, name, binds)
+          @lock.synchronize do
+            if @query_cache[sql].key?(binds)
+              ActiveSupport::Notifications.instrument(
+                "sql.active_record",
+                cache_notification_info(sql, name, binds)
+              )
+              @query_cache[sql][binds]
+            end
+          end
+        end
+
         def cache_sql(sql, name, binds)
           @lock.synchronize do
             result =
@@ -134,13 +153,6 @@ module ActiveRecord
           }
         end
 
-        # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
-        # queries should not be cached.
-        def locked?(arel)
-          arel = arel.arel if arel.is_a?(Relation)
-          arel.respond_to?(:locked) && arel.locked
-        end
-
         def configure_query_cache!
           enable_query_cache! if pool.query_cache_enabled
         end

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

@@ -9,38 +9,46 @@ module ActiveRecord
       # Quotes the column value to help prevent
       # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
       def quote(value)
-        if value.is_a?(Base)
-          ActiveSupport::Deprecation.warn(<<~MSG)
-            Passing an Active Record object to `quote` directly is deprecated
-            and will be no longer quoted as id value in Rails 6.2.
-          MSG
-          value = value.id_for_database
+        case value
+        when String, Symbol, ActiveSupport::Multibyte::Chars
+          "'#{quote_string(value.to_s)}'"
+        when true       then quoted_true
+        when false      then quoted_false
+        when nil        then "NULL"
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s("F")
+        when Numeric, ActiveSupport::Duration then value.to_s
+        when Type::Binary::Data then quoted_binary(value)
+        when Type::Time::Value then "'#{quoted_time(value)}'"
+        when Date, Time then "'#{quoted_date(value)}'"
+        when Class      then "'#{value}'"
+        else raise TypeError, "can't quote #{value.class.name}"
         end
-
-        _quote(value)
       end
 
       # Cast a +value+ to a type that the database understands. For example,
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
-      def type_cast(value, column = nil)
-        if value.is_a?(Base)
-          ActiveSupport::Deprecation.warn(<<~MSG)
-            Passing an Active Record object to `type_cast` directly is deprecated
-            and will be no longer type casted as id value in Rails 6.2.
-          MSG
-          value = value.id_for_database
-        end
-
-        if column
-          ActiveSupport::Deprecation.warn(<<~MSG)
-            Passing a column to `type_cast` is deprecated and will be removed in Rails 6.2.
-          MSG
-          type = lookup_cast_type_from_column(column)
-          value = type.serialize(value)
+      def type_cast(value)
+        case value
+        when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+          value.to_s
+        when true       then unquoted_true
+        when false      then unquoted_false
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s("F")
+        when nil, Numeric, String then value
+        when Type::Time::Value then quoted_time(value)
+        when Date, Time then quoted_date(value)
+        else raise TypeError, "can't cast #{value.class.name}"
         end
+      end
 
-        _type_cast(value)
+      # Quote a value to be used as a bound parameter of unknown type. For example,
+      # MySQL might perform dangerous castings when comparing a string to a number,
+      # so this method will cast numbers to string.
+      def quote_bound_value(value)
+        quote(value)
       end
 
       # If you are having to call this function, you are likely doing something
@@ -59,7 +67,7 @@ module ActiveRecord
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
-        s.gsub('\\', '\&\&').gsub("'", "''") # ' (for ruby-mode)
+        s.gsub("\\", '\&\&').gsub("'", "''") # ' (for ruby-mode)
       end
 
       # Quotes the column name. Defaults to no quoting.
@@ -113,14 +121,14 @@ module ActiveRecord
       # if the value is a Time responding to usec.
       def quoted_date(value)
         if value.acts_like?(:time)
-          if ActiveRecord::Base.default_timezone == :utc
-            value = value.getutc if value.respond_to?(:getutc) && !value.utc?
+          if ActiveRecord.default_timezone == :utc
+            value = value.getutc if !value.utc?
           else
-            value = value.getlocal if value.respond_to?(:getlocal)
+            value = value.getlocal
           end
         end
 
-        result = value.to_s(:db)
+        result = value.to_formatted_s(:db)
         if value.respond_to?(:usec) && value.usec > 0
           result << "." << sprintf("%06d", value.usec)
         else
@@ -196,16 +204,11 @@ module ActiveRecord
 
       private
         def type_casted_binds(binds)
-          case binds.first
-          when Array
-            binds.map { |column, value| type_cast(value, column) }
-          else
-            binds.map do |value|
-              if ActiveModel::Attribute === value
-                type_cast(value.value_for_database)
-              else
-                type_cast(value)
-              end
+          binds.map do |value|
+            if ActiveModel::Attribute === value
+              type_cast(value.value_for_database)
+            else
+              type_cast(value)
             end
           end
         end
@@ -213,39 +216,6 @@ module ActiveRecord
         def lookup_cast_type(sql_type)
           type_map.lookup(sql_type)
         end
-
-        def _quote(value)
-          case value
-          when String, Symbol, ActiveSupport::Multibyte::Chars
-            "'#{quote_string(value.to_s)}'"
-          when true       then quoted_true
-          when false      then quoted_false
-          when nil        then "NULL"
-          # BigDecimals need to be put in a non-normalized form and quoted.
-          when BigDecimal then value.to_s("F")
-          when Numeric, ActiveSupport::Duration then value.to_s
-          when Type::Binary::Data then quoted_binary(value)
-          when Type::Time::Value then "'#{quoted_time(value)}'"
-          when Date, Time then "'#{quoted_date(value)}'"
-          when Class      then "'#{value}'"
-          else raise TypeError, "can't quote #{value.class.name}"
-          end
-        end
-
-        def _type_cast(value)
-          case value
-          when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-            value.to_s
-          when true       then unquoted_true
-          when false      then unquoted_false
-          # BigDecimals need to be put in a non-normalized form and quoted.
-          when BigDecimal then value.to_s("F")
-          when nil, Numeric, String then value
-          when Type::Time::Value then quoted_time(value)
-          when Date, Time then quoted_date(value)
-          else raise TypeError, "can't cast #{value.class.name}"
-          end
-        end
     end
   end
 end

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

@@ -14,8 +14,8 @@ module ActiveRecord
       end
 
       delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-        :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_options,
-        :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?, :check_constraint_options,
+        :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?,
+        :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?,
         to: :@conn, private: true
 
       private
@@ -52,11 +52,11 @@ module ActiveRecord
           end
 
           if supports_foreign_keys?
-            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+            statements.concat(o.foreign_keys.map { |fk| accept fk })
           end
 
           if supports_check_constraints?
-            statements.concat(o.check_constraints.map { |expression, options| check_constraint_in_create(o.name, expression, options) })
+            statements.concat(o.check_constraints.map { |chk| accept chk })
           end
 
           create_sql << "(#{statements.join(', ')})" if statements.present?
@@ -159,19 +159,6 @@ module ActiveRecord
           " TEMPORARY" if o.temporary
         end
 
-        def foreign_key_in_create(from_table, to_table, options)
-          prefix = ActiveRecord::Base.table_name_prefix
-          suffix = ActiveRecord::Base.table_name_suffix
-          to_table = "#{prefix}#{to_table}#{suffix}"
-          options = foreign_key_options(from_table, to_table, options)
-          accept ForeignKeyDefinition.new(from_table, to_table, options)
-        end
-
-        def check_constraint_in_create(table_name, expression, options)
-          options = check_constraint_options(table_name, expression, options)
-          accept CheckConstraintDefinition.new(table_name, expression, options)
-        end
-
         def action_sql(action, dependency)
           case dependency
           when :nullify then "ON #{action} SET NULL"

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  module ConnectionAdapters #:nodoc:
+  module ConnectionAdapters # :nodoc:
     # Abstract representation of an index definition on a table. Instances of
     # this type are typically created and returned by methods in database
     # adapters. e.g. ActiveRecord::ConnectionAdapters::MySQL::SchemaStatements#indexes
@@ -79,13 +79,13 @@ module ActiveRecord
 
     AddColumnDefinition = Struct.new(:column) # :nodoc:
 
-    ChangeColumnDefinition = Struct.new(:column, :name) #:nodoc:
+    ChangeColumnDefinition = Struct.new(:column, :name) # :nodoc:
 
     CreateIndexDefinition = Struct.new(:index, :algorithm, :if_not_exists) # :nodoc:
 
     PrimaryKeyDefinition = Struct.new(:name) # :nodoc:
 
-    ForeignKeyDefinition = Struct.new(:from_table, :to_table, :options) do #:nodoc:
+    ForeignKeyDefinition = Struct.new(:from_table, :to_table, :options) do # :nodoc:
       def name
         options[:name]
       end
@@ -106,6 +106,10 @@ module ActiveRecord
         options[:on_update]
       end
 
+      def deferrable
+        options[:deferrable]
+      end
+
       def custom_primary_key?
         options[:primary_key] != default_primary_key
       end
@@ -253,6 +257,7 @@ module ActiveRecord
         define_column_methods :bigint, :binary, :boolean, :date, :datetime, :decimal,
           :float, :integer, :json, :string, :text, :time, :timestamp, :virtual
 
+        alias :blob :binary
         alias :numeric :decimal
       end
 
@@ -277,7 +282,7 @@ module ActiveRecord
     # Inside migration files, the +t+ object in {create_table}[rdoc-ref:SchemaStatements#create_table]
     # is actually of this type:
     #
-    #   class SomeMigration < ActiveRecord::Migration[6.0]
+    #   class SomeMigration < ActiveRecord::Migration[7.0]
     #     def up
     #       create_table :foo do |t|
     #         puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
@@ -410,6 +415,12 @@ module ActiveRecord
           end
         end
 
+        if @conn.supports_datetime_with_precision?
+          if type == :datetime && !options.key?(:precision)
+            options[:precision] = 6
+          end
+        end
+
         @columns_hash[name] = new_column_definition(name, type, **options)
 
         if index
@@ -434,12 +445,12 @@ module ActiveRecord
         indexes << [column_name, options]
       end
 
-      def foreign_key(table_name, **options) # :nodoc:
-        foreign_keys << [table_name, options]
+      def foreign_key(to_table, **options)
+        foreign_keys << new_foreign_key_definition(to_table, options)
       end
 
       def check_constraint(expression, **options)
-        check_constraints << [expression, options]
+        check_constraints << new_check_constraint_definition(expression, options)
       end
 
       # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
@@ -481,6 +492,19 @@ module ActiveRecord
         create_column_definition(name, type, options)
       end
 
+      def new_foreign_key_definition(to_table, options) # :nodoc:
+        prefix = ActiveRecord::Base.table_name_prefix
+        suffix = ActiveRecord::Base.table_name_suffix
+        to_table = "#{prefix}#{to_table}#{suffix}"
+        options = @conn.foreign_key_options(name, to_table, options)
+        ForeignKeyDefinition.new(name, to_table, options)
+      end
+
+      def new_check_constraint_definition(expression, options) # :nodoc:
+        options = @conn.check_constraint_options(name, expression, options)
+        CheckConstraintDefinition.new(name, expression, options)
+      end
+
       private
         def create_column_definition(name, type, options)
           ColumnDefinition.new(name, type, options)
@@ -516,7 +540,7 @@ module ActiveRecord
       def name; @td.name; end
 
       def add_foreign_key(to_table, options)
-        @foreign_key_adds << ForeignKeyDefinition.new(name, to_table, options)
+        @foreign_key_adds << @td.new_foreign_key_definition(to_table, options)
       end
 
       def drop_foreign_key(name)
@@ -524,7 +548,7 @@ module ActiveRecord
       end
 
       def add_check_constraint(expression, options)
-        @check_constraint_adds << CheckConstraintDefinition.new(name, expression, options)
+        @check_constraint_adds << @td.new_check_constraint_definition(expression, options)
       end
 
       def drop_check_constraint(constraint_name)
@@ -568,6 +592,7 @@ module ActiveRecord
     #     t.time
     #     t.date
     #     t.binary
+    #     t.blob
     #     t.boolean
     #     t.foreign_key
     #     t.json