activerecord 7.0.6 → 7.1.0.beta1

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

@@ -15,7 +15,12 @@ module ActiveRecord
       end
 
       def to_sql_and_binds(arel_or_sql_string, binds = [], preparable = nil) # :nodoc:
+        # Arel::TreeManager -> Arel::Node
         if arel_or_sql_string.respond_to?(:ast)
+          arel_or_sql_string = arel_or_sql_string.ast
+        end
+
+        if Arel.arel_node?(arel_or_sql_string) && !(String === arel_or_sql_string)
           unless binds.empty?
             raise "Passing bind parameters with an arel AST is forbidden. " \
               "The values must be stored on the AST directly"
@@ -25,7 +30,7 @@ module ActiveRecord
 
           if prepared_statements
             collector.preparable = true
-            sql, binds = visitor.compile(arel_or_sql_string.ast, collector)
+            sql, binds = visitor.compile(arel_or_sql_string, collector)
 
             if binds.length > bind_params_length
               unprepared_statement do
@@ -34,7 +39,7 @@ module ActiveRecord
             end
             preparable = collector.preparable
           else
-            sql = visitor.compile(arel_or_sql_string.ast, collector)
+            sql = visitor.compile(arel_or_sql_string, collector)
           end
           [sql.freeze, binds, preparable]
         else
@@ -65,18 +70,18 @@ module ActiveRecord
 
         select(sql, name, binds, prepare: prepared_statements && preparable, async: async && FutureResult::SelectAll)
       rescue ::RangeError
-        ActiveRecord::Result.empty
+        ActiveRecord::Result.empty(async: async)
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
-      def select_one(arel, name = nil, binds = [])
-        select_all(arel, name, binds).first
+      def select_one(arel, name = nil, binds = [], async: false)
+        select_all(arel, name, binds, async: async).then(&:first)
       end
 
       # Returns a single value from a record
-      def select_value(arel, name = nil, binds = [])
-        single_value_from_rows(select_rows(arel, name, binds))
+      def select_value(arel, name = nil, binds = [], async: false)
+        select_rows(arel, name, binds, async: async).then { |rows| single_value_from_rows(rows) }
       end
 
       # Returns an array of the values of the first column in a select:
@@ -87,8 +92,8 @@ module ActiveRecord
 
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
-      def select_rows(arel, name = nil, binds = [])
-        select_all(arel, name, binds).rows
+      def select_rows(arel, name = nil, binds = [], async: false)
+        select_all(arel, name, binds, async: async).then(&:rows)
       end
 
       def query_value(sql, name = nil) # :nodoc:
@@ -100,7 +105,7 @@ module ActiveRecord
       end
 
       def query(sql, name = nil) # :nodoc:
-        exec_query(sql, name).rows
+        internal_exec_query(sql, name).rows
       end
 
       # Determines whether the SQL statement is a write query.
@@ -110,47 +115,63 @@ module ActiveRecord
 
       # Executes the SQL statement in the context of this connection and returns
       # the raw result from the connection adapter.
+      #
+      # Setting +allow_retry+ to true causes the db to reconnect and retry
+      # executing the SQL statement in case of a connection-related exception.
+      # This option should only be enabled for known idempotent queries.
+      #
+      # Note: the query is assumed to have side effects and the query cache
+      # will be cleared. If the query is read-only, consider using #select_all
+      # instead.
+      #
       # Note: depending on your database connector, the result returned by this
-      # method may be manually memory managed. Consider using the exec_query
+      # method may be manually memory managed. Consider using #exec_query
       # wrapper instead.
-      def execute(sql, name = nil)
-        raise NotImplementedError
+      def execute(sql, name = nil, allow_retry: false)
+        internal_execute(sql, name, allow_retry: allow_retry)
       end
 
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
+      #
+      # Note: the query is assumed to have side effects and the query cache
+      # will be cleared. If the query is read-only, consider using #select_all
+      # instead.
       def exec_query(sql, name = "SQL", binds = [], prepare: false)
-        raise NotImplementedError
+        internal_exec_query(sql, name, binds, prepare: prepare)
       end
 
       # Executes insert +sql+ statement in the context of this connection using
       # +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, binds)
-        exec_query(sql, name, binds)
+      # Some adapters support the `returning` keyword argument which allows to control the result of the query:
+      # `nil` is the default value and maintains default behavior. If an array of column names is passed -
+      # the result will contain values of the specified columns from the inserted row.
+      def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+        sql, binds = sql_for_insert(sql, pk, binds, returning)
+        internal_exec_query(sql, name, binds)
       end
 
       # Executes delete +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_delete(sql, name = nil, binds = [])
-        exec_query(sql, name, binds)
+        internal_exec_query(sql, name, binds)
       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.
       def exec_update(sql, name = nil, binds = [])
-        exec_query(sql, name, binds)
+        internal_exec_query(sql, name, binds)
       end
 
       def exec_insert_all(sql, name) # :nodoc:
-        exec_query(sql, name)
+        internal_exec_query(sql, name)
       end
 
-      def explain(arel, binds = []) # :nodoc:
+      def explain(arel, binds = [], options = []) # :nodoc:
         raise NotImplementedError
       end
 
@@ -162,10 +183,14 @@ module ActiveRecord
       #
       # If the next id was calculated in advance (as in Oracle), it should be
       # passed in as +id_value+.
-      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+      # Some adapters support the `returning` keyword argument which allows defining the return value of the method:
+      # `nil` is the default value and maintains default behavior. If an array of column names is passed -
+      # an array of is returned from the method representing values of the specified columns from the inserted row.
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
         sql, binds = to_sql_and_binds(arel, binds)
-        value = exec_insert(sql, name, binds, pk, sequence_name)
-        id_value || last_inserted_id(value)
+        value = exec_insert(sql, name, binds, pk, sequence_name, returning: returning)
+        return id_value if id_value
+        returning.nil? ? last_inserted_id(value) : returning_column_values(value)
       end
       alias create insert
 
@@ -187,7 +212,7 @@ module ActiveRecord
       end
 
       def truncate_tables(*table_names) # :nodoc:
-        table_names -= [schema_migration.table_name, InternalMetadata.table_name]
+        table_names -= [schema_migration.table_name, internal_metadata.table_name]
 
         return if table_names.empty?
 
@@ -304,8 +329,9 @@ module ActiveRecord
       # * You are joining an existing open transaction
       # * You are creating a nested (savepoint) transaction
       #
-      # The mysql2 and postgresql adapters support setting the transaction
+      # The mysql2, trilogy, and postgresql adapters support setting the transaction
       # isolation level.
+      #  :args: (requires_new: nil, isolation: nil, &block)
       def transaction(requires_new: nil, isolation: nil, joinable: true, &block)
         if !requires_new && current_transaction.joinable?
           if isolation
@@ -323,7 +349,8 @@ module ActiveRecord
 
       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
+               :disable_lazy_transactions!, :enable_lazy_transactions!, :dirty_current_transaction,
+               to: :transaction_manager
 
       def mark_transaction_written_if_write(sql) # :nodoc:
         transaction = current_transaction
@@ -336,8 +363,24 @@ module ActiveRecord
         current_transaction.open?
       end
 
-      def reset_transaction # :nodoc:
+      def reset_transaction(restore: false) # :nodoc:
+        # Store the existing transaction state to the side
+        old_state = @transaction_manager if restore && @transaction_manager&.restorable?
+
         @transaction_manager = ConnectionAdapters::TransactionManager.new(self)
+
+        if block_given?
+          # Reconfigure the connection without any transaction state in the way
+          result = yield
+
+          # Now the connection's fully established, we can swap back
+          if old_state
+            @transaction_manager = old_state
+            @transaction_manager.restore_transactions
+          end
+
+          result
+        end
       end
 
       # Register a record with the current transaction so that its after_commit and after_rollback callbacks
@@ -372,10 +415,18 @@ module ActiveRecord
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction
         exec_rollback_db_transaction
+      rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::ConnectionFailed
+        # Connection's gone; that counts as a rollback
       end
 
       def exec_rollback_db_transaction() end # :nodoc:
 
+      def restart_db_transaction
+        exec_restart_db_transaction
+      end
+
+      def exec_restart_db_transaction() end # :nodoc:
+
       def rollback_to_savepoint(name = nil)
         exec_rollback_to_savepoint(name)
       end
@@ -393,7 +444,7 @@ module ActiveRecord
       # something beyond a simple insert (e.g. Oracle).
       # 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.
+      # for databases like SQLite that do not support bulk inserts.
       def insert_fixture(fixture, table_name)
         execute(build_fixture_sql(Array.wrap(fixture), table_name), "Fixture Insert")
       end
@@ -454,13 +505,30 @@ module ActiveRecord
         HIGH_PRECISION_CURRENT_TIMESTAMP
       end
 
+      def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
+        raise NotImplementedError
+      end
+
       private
+        def internal_execute(sql, name = "SCHEMA", allow_retry: false, materialize_transactions: true)
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+
+          mark_transaction_written_if_write(sql)
+
+          raw_execute(sql, name, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
+        end
+
         def execute_batch(statements, name = nil)
           statements.each do |statement|
-            execute(statement, name)
+            internal_execute(statement, name)
           end
         end
 
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+          raise NotImplementedError
+        end
+
         DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
         private_constant :DEFAULT_INSERT_VALUE
 
@@ -557,10 +625,15 @@ module ActiveRecord
             return future_result
           end
 
-          exec_query(sql, name, binds, prepare: prepare)
+          result = internal_exec_query(sql, name, binds, prepare: prepare)
+          if async
+            FutureResult::Complete.new(result)
+          else
+            result
+          end
         end
 
-        def sql_for_insert(sql, pk, binds)
+        def sql_for_insert(sql, _pk, binds, _returning)
           [sql, binds]
         end
 
@@ -568,6 +641,10 @@ module ActiveRecord
           single_value_from_rows(result.rows)
         end
 
+        def returning_column_values(result)
+          [last_inserted_id(result)]
+        end
+
         def single_value_from_rows(rows)
           row = rows.first
           row && row.first

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

@@ -5,10 +5,13 @@ require "concurrent/map"
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module QueryCache
+      DEFAULT_SIZE = 100 # :nodoc:
+
       class << self
         def included(base) # :nodoc:
-          dirties_query_cache base, :create, :insert, :update, :delete, :truncate, :truncate_tables,
-            :rollback_to_savepoint, :rollback_db_transaction, :exec_insert_all
+          dirties_query_cache base, :exec_query, :execute, :create, :insert, :update, :delete, :truncate,
+            :truncate_tables, :rollback_to_savepoint, :rollback_db_transaction, :restart_db_transaction,
+            :exec_insert_all
 
           base.set_callback :checkout, :after, :configure_query_cache!
           base.set_callback :checkin, :after, :disable_query_cache!
@@ -17,7 +20,7 @@ module ActiveRecord
         def dirties_query_cache(base, *method_names)
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
-              def #{method_name}(*)
+              def #{method_name}(...)
                 ActiveRecord::Base.clear_query_caches_for_current_thread
                 super
               end
@@ -51,8 +54,9 @@ module ActiveRecord
 
       def initialize(*)
         super
-        @query_cache         = Hash.new { |h, sql| h[sql] = {} }
+        @query_cache         = {}
         @query_cache_enabled = false
+        @query_cache_max_size = nil
       end
 
       # Enable the query cache within the block.
@@ -93,7 +97,7 @@ module ActiveRecord
         end
       end
 
-      def select_all(arel, name = nil, binds = [], preparable: nil, async: false)
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false) # :nodoc:
         arel = arel_from_relation(arel)
 
         # If arel is locked this is a SELECT ... FOR UPDATE or somesuch.
@@ -113,31 +117,52 @@ module ActiveRecord
 
       private
         def lookup_sql_cache(sql, name, binds)
+          key = binds.empty? ? sql : [sql, binds]
+          hit = false
+          result = nil
+
           @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]
+            if (result = @query_cache.delete(key))
+              hit = true
+              @query_cache[key] = result
             end
           end
+
+          if hit
+            ActiveSupport::Notifications.instrument(
+              "sql.active_record",
+              cache_notification_info(sql, name, binds)
+            )
+
+            result
+          end
         end
 
         def cache_sql(sql, name, binds)
+          key = binds.empty? ? sql : [sql, binds]
+          result = nil
+          hit = false
+
           @lock.synchronize do
-            result =
-              if @query_cache[sql].key?(binds)
-                ActiveSupport::Notifications.instrument(
-                  "sql.active_record",
-                  cache_notification_info(sql, name, binds)
-                )
-                @query_cache[sql][binds]
-              else
-                @query_cache[sql][binds] = yield
+            if (result = @query_cache.delete(key))
+              hit = true
+              @query_cache[key] = result
+            else
+              result = @query_cache[key] = yield
+              if @query_cache_max_size && @query_cache.size > @query_cache_max_size
+                @query_cache.shift
               end
-            result.dup
+            end
           end
+
+          if hit
+            ActiveSupport::Notifications.instrument(
+              "sql.active_record",
+              cache_notification_info(sql, name, binds)
+            )
+          end
+
+          result.dup
         end
 
         # Database adapters can override this method to
@@ -154,7 +179,20 @@ module ActiveRecord
         end
 
         def configure_query_cache!
-          enable_query_cache! if pool.query_cache_enabled
+          case query_cache = pool.db_config.query_cache
+          when 0, false
+            return
+          when Integer
+            @query_cache_max_size = query_cache
+          when nil
+            @query_cache_max_size = DEFAULT_SIZE
+          else
+            @query_cache_max_size = nil # no limit
+          end
+
+          if pool.query_cache_enabled
+            enable_query_cache!
+          end
         end
     end
   end

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

@@ -5,6 +5,7 @@ require "active_support/multibyte/chars"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
+    # = Active Record Connection Adapters \Quoting
     module Quoting
       # Quotes the column value to help prevent
       # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
@@ -17,11 +18,14 @@ module ActiveRecord
         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 Numeric 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}'"
+        when ActiveSupport::Duration
+          warn_quote_duration_deprecated
+          value.to_s
         else raise TypeError, "can't quote #{value.class.name}"
         end
       end
@@ -47,8 +51,23 @@ module ActiveRecord
       # 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.
+      #
+      # Deprecated: Consider `Arel.sql("... ? ...", value)` or
+      # +sanitize_sql+ instead.
       def quote_bound_value(value)
-        quote(value)
+        ActiveRecord.deprecator.warn(<<~MSG.squish)
+          #quote_bound_value is deprecated and will be removed in Rails 7.2.
+          Consider Arel.sql(".. ? ..", value) or #sanitize_sql instead.
+        MSG
+
+        quote(cast_bound_value(value))
+      end
+
+      # Cast 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 cast_bound_value(value) # :nodoc:
+        value
       end
 
       # If you are having to call this function, you are likely doing something
@@ -83,7 +102,7 @@ module ActiveRecord
       # Override to return the quoted table name for assignment. Defaults to
       # table quoting.
       #
-      # This works for mysql2 where table.column can be used to
+      # This works for MySQL where table.column can be used to
       # resolve ambiguity.
       #
       # We override this in the sqlite3 and postgresql adapters to use only
@@ -121,7 +140,7 @@ module ActiveRecord
       # if the value is a Time responding to usec.
       def quoted_date(value)
         if value.acts_like?(:time)
-          if ActiveRecord.default_timezone == :utc
+          if default_timezone == :utc
             value = value.getutc if !value.utc?
           else
             value = value.getlocal
@@ -176,7 +195,7 @@ module ActiveRecord
         (
           (?:
             # table_name.column_name | function(one or no argument)
-            ((?:\w+\.)?\w+) | \w+\((?:|\g<2>)\)
+            ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
           )
           (?:(?:\s+AS)?\s+\w+)?
         )
@@ -200,7 +219,7 @@ module ActiveRecord
         (
           (?:
             # table_name.column_name | function(one or no argument)
-            ((?:\w+\.)?\w+) | \w+\((?:|\g<2>)\)
+            ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
           )
           (?:\s+ASC|\s+DESC)?
           (?:\s+NULLS\s+(?:FIRST|LAST))?
@@ -225,6 +244,22 @@ module ActiveRecord
         def lookup_cast_type(sql_type)
           type_map.lookup(sql_type)
         end
+
+        def warn_quote_duration_deprecated
+          ActiveRecord.deprecator.warn(<<~MSG)
+            Using ActiveSupport::Duration as an interpolated bind parameter in a SQL
+            string template is deprecated. To avoid this warning, you should explicitly
+            convert the duration to a more specific database type. For example, if you
+            want to use a duration as an integer number of seconds:
+            ```
+            Record.where("duration = ?", 1.hour.to_i)
+            ```
+            If you want to use a duration as an ISO 8601 string:
+            ```
+            Record.where("duration = ?", 1.hour.iso8601)
+            ```
+          MSG
+        end
     end
   end
 end

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

@@ -2,21 +2,22 @@
 
 module ActiveRecord
   module ConnectionAdapters
+    # = Active Record Connection Adapters \Savepoints
     module Savepoints
       def current_savepoint_name
         current_transaction.savepoint_name
       end
 
       def create_savepoint(name = current_savepoint_name)
-        execute("SAVEPOINT #{name}", "TRANSACTION")
+        internal_execute("SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def exec_rollback_to_savepoint(name = current_savepoint_name)
-        execute("ROLLBACK TO SAVEPOINT #{name}", "TRANSACTION")
+        internal_execute("ROLLBACK TO SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def release_savepoint(name = current_savepoint_name)
-        execute("RELEASE SAVEPOINT #{name}", "TRANSACTION")
+        internal_execute("RELEASE SAVEPOINT #{name}", "TRANSACTION")
       end
     end
   end

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

@@ -14,8 +14,10 @@ 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?,
+        :options_include_default?, :supports_indexes_in_create?, :use_foreign_keys?,
         :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?,
+        :supports_index_include?, :supports_exclusion_constraints?, :supports_unique_keys?,
+        :supports_nulls_not_distinct?,
         to: :@conn, private: true
 
       private
@@ -51,7 +53,7 @@ module ActiveRecord
             statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
           end
 
-          if supports_foreign_keys?
+          if use_foreign_keys?
             statements.concat(o.foreign_keys.map { |fk| accept fk })
           end
 
@@ -59,6 +61,14 @@ module ActiveRecord
             statements.concat(o.check_constraints.map { |chk| accept chk })
           end
 
+          if supports_exclusion_constraints?
+            statements.concat(o.exclusion_constraints.map { |exc| accept exc })
+          end
+
+          if supports_unique_keys?
+            statements.concat(o.unique_keys.map { |exc| accept exc })
+          end
+
           create_sql << "(#{statements.join(', ')})" if statements.present?
           add_table_options!(create_sql, o)
           create_sql << " AS #{to_sql(o.as)}" if o.as
@@ -70,10 +80,12 @@ module ActiveRecord
         end
 
         def visit_ForeignKeyDefinition(o)
+          quoted_columns = Array(o.column).map { |c| quote_column_name(c) }
+          quoted_primary_keys = Array(o.primary_key).map { |c| quote_column_name(c) }
           sql = +<<~SQL
             CONSTRAINT #{quote_column_name(o.name)}
-            FOREIGN KEY (#{quote_column_name(o.column)})
-              REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
+            FOREIGN KEY (#{quoted_columns.join(", ")})
+              REFERENCES #{quote_table_name(o.to_table)} (#{quoted_primary_keys.join(", ")})
           SQL
           sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
           sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
@@ -100,6 +112,8 @@ module ActiveRecord
           sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
           sql << "USING #{index.using}" if supports_index_using? && index.using
           sql << "(#{quoted_columns(index)})"
+          sql << "INCLUDE (#{quoted_include_columns(index.include)})" if supports_index_include? && index.include
+          sql << "NULLS NOT DISTINCT" if supports_nulls_not_distinct? && index.nulls_not_distinct
           sql << "WHERE #{index.where}" if supports_partial_index? && index.where
 
           sql.join(" ")