Merge pull request rails#48068 from Shopify/ar-materialize-transactions

Rename `uses_transactions` to `materialize_transactions`

Author: byroot

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

@@ -491,13 +491,13 @@ def high_precision_current_timestamp
       end
 
       private
-        def internal_execute(sql, name = "SCHEMA", allow_retry: false, uses_transaction: true)
+        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, uses_transaction: uses_transaction)
+          raw_execute(sql, name, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
         end
 
         def execute_batch(statements, name = nil)
@@ -506,7 +506,7 @@ def execute_batch(statements, name = nil)
           end
         end
 
-        def raw_execute(sql, name, async: false, allow_retry: false, uses_transaction: true)
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
           raise NotImplementedError
         end
 

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -963,7 +963,7 @@ def reconnect_can_restore_state?
         # the connection's configured +connection_retries+ setting
         # and the configured +retry_deadline+ limit.
         #
-        # If +uses_transaction+ is false, the block will be run without
+        # If +materialize_transactions+ is false, the block will be run without
         # ensuring virtual transactions have been materialized in the DB
         # server's state. The active transaction will also remain clean
         # (if it is not already dirty), meaning it's able to be restored
@@ -983,11 +983,11 @@ def reconnect_can_restore_state?
         # still-yielded connection in the outer block), but we currently
         # provide no special enforcement there.
         #
-        def with_raw_connection(allow_retry: false, uses_transaction: true)
+        def with_raw_connection(allow_retry: false, materialize_transactions: true)
           @lock.synchronize do
             connect! if @raw_connection.nil? && reconnect_can_restore_state?
 
-            materialize_transactions if uses_transaction
+            self.materialize_transactions if materialize_transactions
 
             retries_available = allow_retry ? connection_retries : 0
             deadline = retry_deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) + retry_deadline
@@ -1044,7 +1044,7 @@ def with_raw_connection(allow_retry: false, uses_transaction: true)
 
               raise translated_exception
             ensure
-              dirty_current_transaction if uses_transaction
+              dirty_current_transaction if materialize_transactions
             end
           end
         end
@@ -1092,7 +1092,7 @@ def valid_raw_connection
             # `allow_retry: false`, to force verification: the block won't
             # raise, so a retry wouldn't help us get the valid connection we
             # need.
-            with_raw_connection(allow_retry: false, uses_transaction: false) { |conn| conn }
+            with_raw_connection(allow_retry: false, materialize_transactions: false) { |conn| conn }
         end
 
         def extended_type_map_key

activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -232,24 +232,24 @@ def execute_and_free(sql, name = nil, async: false) # :nodoc:
       end
 
       def begin_db_transaction # :nodoc:
-        internal_execute("BEGIN", "TRANSACTION", allow_retry: true, uses_transaction: false)
+        internal_execute("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
       end
 
       def begin_isolated_db_transaction(isolation) # :nodoc:
-        internal_execute("SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "TRANSACTION", allow_retry: true, uses_transaction: false)
+        internal_execute("SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         begin_db_transaction
       end
 
       def commit_db_transaction # :nodoc:
-        internal_execute("COMMIT", "TRANSACTION", allow_retry: false, uses_transaction: true)
+        internal_execute("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
       end
 
       def exec_rollback_db_transaction # :nodoc:
-        internal_execute("ROLLBACK", "TRANSACTION", allow_retry: false, uses_transaction: true)
+        internal_execute("ROLLBACK", "TRANSACTION", allow_retry: false, materialize_transactions: true)
       end
 
       def exec_restart_db_transaction # :nodoc:
-        internal_execute("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, uses_transaction: true)
+        internal_execute("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, materialize_transactions: true)
       end
 
       def empty_insert_statement_value(primary_key = nil) # :nodoc:

activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb

@@ -165,9 +165,9 @@ def max_allowed_packet
             @max_allowed_packet ||= show_variable("max_allowed_packet")
           end
 
-          def raw_execute(sql, name, async: false, allow_retry: false, uses_transaction: true)
+          def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
             log(sql, name, async: async) do
-              with_raw_connection(allow_retry: allow_retry, uses_transaction: uses_transaction) do |conn|
+              with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
                 sync_timezone_changes(conn)
                 result = conn.query(sql)
                 handle_warnings(sql)

activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -104,7 +104,7 @@ def error_number(exception)
 
       # Quotes strings for use in SQL input.
       def quote_string(string)
-        with_raw_connection(allow_retry: true, uses_transaction: false) do |connection|
+        with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
           connection.escape(string)
         end
       end

activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -47,18 +47,18 @@ def execute(...) # :nodoc:
           @notice_receiver_sql_warnings = []
         end
 
-        def raw_execute(sql, name, async: false, allow_retry: false, uses_transaction: true)
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
           log(sql, name, async: async) do
-            with_raw_connection(allow_retry: allow_retry, uses_transaction: uses_transaction) do |conn|
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
               result = conn.async_exec(sql)
               handle_warnings(result)
               result
             end
           end
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, uses_transaction: true) # :nodoc:
-          execute_and_clear(sql, name, binds, prepare: prepare, async: async, allow_retry: allow_retry, uses_transaction: uses_transaction) do |result|
+        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true) # :nodoc:
+          execute_and_clear(sql, name, binds, prepare: prepare, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |result|
             types = {}
             fields = result.fields
             fields.each_with_index do |fname, i|
@@ -110,27 +110,27 @@ def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil) # :n
 
         # Begins a transaction.
         def begin_db_transaction # :nodoc:
-          internal_execute("BEGIN", "TRANSACTION", allow_retry: true, uses_transaction: false)
+          internal_execute("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
         def begin_isolated_db_transaction(isolation) # :nodoc:
-          internal_execute("BEGIN ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "TRANSACTION", allow_retry: true, uses_transaction: false)
+          internal_execute("BEGIN ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
         # Commits a transaction.
         def commit_db_transaction # :nodoc:
-          internal_execute("COMMIT", "TRANSACTION", allow_retry: false, uses_transaction: true)
+          internal_execute("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         # Aborts a transaction.
         def exec_rollback_db_transaction # :nodoc:
           cancel_any_running_query
-          internal_execute("ROLLBACK", "TRANSACTION", allow_retry: false, uses_transaction: true)
+          internal_execute("ROLLBACK", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         def exec_restart_db_transaction # :nodoc:
           cancel_any_running_query
-          internal_execute("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, uses_transaction: true)
+          internal_execute("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT

activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -69,7 +69,7 @@ def quote(value) # :nodoc:
 
         # Quotes strings for use in SQL input.
         def quote_string(s) # :nodoc:
-          with_raw_connection(allow_retry: true, uses_transaction: false) do |connection|
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
             connection.escape(s)
           end
         end

activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -520,7 +520,7 @@ def index_name(table_name, options) # :nodoc:
 
         def foreign_keys(table_name)
           scope = quoted_scope(table_name)
-          fk_info = exec_query(<<~SQL, "SCHEMA", allow_retry: true, uses_transaction: false)
+          fk_info = exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
             SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
@@ -563,7 +563,7 @@ def foreign_table_exists?(table_name)
         def check_constraints(table_name) # :nodoc:
           scope = quoted_scope(table_name)
 
-          check_info = exec_query(<<-SQL, "SCHEMA", allow_retry: true, uses_transaction: false)
+          check_info = exec_query(<<-SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
             SELECT conname, pg_get_constraintdef(c.oid, true) AS constraintdef, c.convalidated AS valid
             FROM pg_constraint c
             JOIN pg_class t ON c.conrelid = t.oid
@@ -623,7 +623,7 @@ def exclusion_constraints(table_name)
         def unique_keys(table_name)
           scope = quoted_scope(table_name)
 
-          unique_info = exec_query(<<~SQL, "SCHEMA", allow_retry: true, uses_transaction: false)
+          unique_info = exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
             SELECT c.conname, c.conindid, c.condeferrable, c.condeferred
             FROM pg_constraint c
             JOIN pg_class t ON c.conrelid = t.oid

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -482,7 +482,7 @@ def extension_enabled?(name)
       end
 
       def extensions
-        exec_query("SELECT extname FROM pg_extension", "SCHEMA", allow_retry: true, uses_transaction: false).cast_values
+        exec_query("SELECT extname FROM pg_extension", "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values
       end
 
       # Returns a list of defined enum types, and their values.
@@ -500,7 +500,7 @@ def enum_types
           GROUP BY type.OID, n.nspname, type.typname;
         SQL
 
-        exec_query(query, "SCHEMA", allow_retry: true, uses_transaction: false).cast_values.each_with_object({}) do |row, memo|
+        exec_query(query, "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values.each_with_object({}) do |row, memo|
           name, schema = row[0], row[2]
           schema = nil if schema == current_schema
           full_name = [schema, name].compact.join(".")
@@ -562,7 +562,7 @@ def table_name_length
       # Set the authorized user for this session
       def session_auth=(user)
         clear_cache!
-        internal_execute("SET SESSION AUTHORIZATION #{user}", nil, uses_transaction: true)
+        internal_execute("SET SESSION AUTHORIZATION #{user}", nil, materialize_transactions: true)
       end
 
       def use_insert_returning?
@@ -801,7 +801,7 @@ def get_oid_type(oid, fmod, column_name, sql_type = "")
         def load_additional_types(oids = nil)
           initializer = OID::TypeMapInitializer.new(type_map)
           load_types_queries(initializer, oids) do |query|
-            execute_and_clear(query, "SCHEMA", [], allow_retry: true, uses_transaction: false) do |records|
+            execute_and_clear(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false) do |records|
               initializer.run(records)
             end
           end
@@ -824,14 +824,14 @@ def load_types_queries(initializer, oids)
 
         FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
 
-        def execute_and_clear(sql, name, binds, prepare: false, async: false, allow_retry: false, uses_transaction: true)
+        def execute_and_clear(sql, name, binds, prepare: false, async: false, allow_retry: false, materialize_transactions: true)
           sql = transform_query(sql)
           check_if_write_query(sql)
 
           if !prepare || without_prepared_statement?(binds)
-            result = exec_no_cache(sql, name, binds, async: async, allow_retry: allow_retry, uses_transaction: uses_transaction)
+            result = exec_no_cache(sql, name, binds, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
           else
-            result = exec_cache(sql, name, binds, async: async, allow_retry: allow_retry, uses_transaction: uses_transaction)
+            result = exec_cache(sql, name, binds, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
           end
           begin
             ret = yield result
@@ -841,7 +841,7 @@ def execute_and_clear(sql, name, binds, prepare: false, async: false, allow_retr
           ret
         end
 
-        def exec_no_cache(sql, name, binds, async:, allow_retry:, uses_transaction:)
+        def exec_no_cache(sql, name, binds, async:, allow_retry:, materialize_transactions:)
           mark_transaction_written_if_write(sql)
 
           # make sure we carry over any changes to ActiveRecord.default_timezone that have been
@@ -856,7 +856,7 @@ def exec_no_cache(sql, name, binds, async:, allow_retry:, uses_transaction:)
           end
         end
 
-        def exec_cache(sql, name, binds, async:, allow_retry:, uses_transaction:)
+        def exec_cache(sql, name, binds, async:, allow_retry:, materialize_transactions:)
           mark_transaction_written_if_write(sql)
 
           update_typemap_for_default_timezone
@@ -915,7 +915,7 @@ def sql_key(sql)
         # Prepare the statement if it hasn't been prepared, return
         # the statement key.
         def prepare_statement(sql, binds)
-          with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
             sql_key = sql_key(sql)
             unless @statements.key? sql_key
               nextkey = @statements.next_key
@@ -1075,7 +1075,7 @@ def can_perform_case_insensitive_comparison_for?(column)
                     AND castsource = #{quote column.sql_type}::regtype
                 )
               SQL
-              execute_and_clear(sql, "SCHEMA", [], allow_retry: true, uses_transaction: false) do |result|
+              execute_and_clear(sql, "SCHEMA", [], allow_retry: true, materialize_transactions: false) do |result|
                 result.getvalue(0, 0)
               end
             end
@@ -1132,7 +1132,7 @@ def add_pg_decoders
             FROM pg_type as t
             WHERE t.typname IN (%s)
           SQL
-          coders = execute_and_clear(query, "SCHEMA", [], allow_retry: true, uses_transaction: false) do |result|
+          coders = execute_and_clear(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false) do |result|
             result.filter_map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
           end
 

activerecord/lib/active_record/connection_adapters/sqlite3/database_statements.rb

@@ -66,7 +66,7 @@ def begin_isolated_db_transaction(isolation) # :nodoc:
           raise TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
           raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
 
-          with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
             ActiveSupport::IsolatedExecutionState[:active_record_read_uncommitted] = conn.get_first_value("PRAGMA read_uncommitted")
             conn.read_uncommitted = true
             begin_db_transaction
@@ -75,15 +75,15 @@ def begin_isolated_db_transaction(isolation) # :nodoc:
 
         def begin_db_transaction # :nodoc:
           log("begin transaction", "TRANSACTION") do
-            with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+            with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
               conn.transaction
             end
           end
         end
 
         def commit_db_transaction # :nodoc:
           log("commit transaction", "TRANSACTION") do
-            with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+            with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
               conn.commit
             end
           end
@@ -92,7 +92,7 @@ def commit_db_transaction # :nodoc:
 
         def exec_rollback_db_transaction # :nodoc:
           log("rollback transaction", "TRANSACTION") do
-            with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+            with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
               conn.rollback
             end
           end
@@ -109,9 +109,9 @@ def high_precision_current_timestamp
         end
 
         private
-          def raw_execute(sql, name, async: false, allow_retry: false, uses_transaction: false)
+          def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: false)
             log(sql, name, async: async) do
-              with_raw_connection(allow_retry: allow_retry, uses_transaction: uses_transaction) do |conn|
+              with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
                 conn.execute(sql)
               end
             end