activerecord 7.2.2.1 → 8.0.5

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -79,7 +79,7 @@ module ActiveRecord
 
           args << config.database
 
-          find_cmd_and_exec(["mysql", "mysql5"], *args)
+          find_cmd_and_exec(ActiveRecord.database_cli[:mysql], *args)
         end
       end
 
@@ -98,7 +98,7 @@ module ActiveRecord
       end
 
       def supports_index_sort_order?
-        !mariadb? && database_version >= "8.0.1"
+        mariadb? ? database_version >= "10.8.1" : database_version >= "8.0.1"
       end
 
       def supports_expression_index?
@@ -138,7 +138,7 @@ module ActiveRecord
       end
 
       def supports_datetime_with_precision?
-        mariadb? || database_version >= "5.6.4"
+        true
       end
 
       def supports_virtual_columns?
@@ -174,6 +174,10 @@ module ActiveRecord
         mariadb? && database_version >= "10.5.0"
       end
 
+      def return_value_after_insert?(column) # :nodoc:
+        supports_insert_returning? ? column.auto_populated? : column.auto_increment?
+      end
+
       def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
         query_value("SELECT GET_LOCK(#{quote(lock_name.to_s)}, #{timeout})") == 1
       end
@@ -197,12 +201,6 @@ module ActiveRecord
 
       # HELPER METHODS ===========================================
 
-      # The two drivers have slightly different ways of yielding hashes of results, so
-      # this method must be implemented to provide a uniform interface.
-      def each_hash(result) # :nodoc:
-        raise NotImplementedError
-      end
-
       # Must return the MySQL error number from the exception, if the exception has an
       # error number.
       def error_number(exception) # :nodoc:
@@ -226,24 +224,19 @@ module ActiveRecord
       # DATABASE STATEMENTS ======================================
       #++
 
-      # Mysql2Adapter doesn't have to free a result after using it, but we use this method
-      # to write stuff in an abstract way without concerning ourselves about whether it
-      # needs to be explicitly freed or not.
-      def execute_and_free(sql, name = nil, async: false, allow_retry: false) # :nodoc:
-        sql = transform_query(sql)
-        check_if_write_query(sql)
-
-        mark_transaction_written_if_write(sql)
-        yield raw_execute(sql, name, async: async, allow_retry: allow_retry)
-      end
-
       def begin_db_transaction # :nodoc:
         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, materialize_transactions: false)
-        begin_db_transaction
+        # From MySQL manual: The [SET TRANSACTION] statement applies only to the next single transaction performed within the session.
+        # So we don't need to implement #reset_isolation_level
+        execute_batch(
+          ["SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "BEGIN"],
+          "TRANSACTION",
+          allow_retry: true,
+          materialize_transactions: false,
+        )
       end
 
       def commit_db_transaction # :nodoc:
@@ -343,7 +336,7 @@ module ActiveRecord
         rename_table_indexes(table_name, new_name, **options)
       end
 
-      # Drops a table from the database.
+      # Drops a table or tables from the database.
       #
       # [<tt>:force</tt>]
       #   Set to +:cascade+ to drop dependent objects as well.
@@ -357,10 +350,10 @@ module ActiveRecord
       #
       # Although this command ignores most +options+ and the block if one is given,
       # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
-      # In that case, +options+ and the block will be used by create_table.
-      def drop_table(table_name, **options)
-        schema_cache.clear_data_source_cache!(table_name.to_s)
-        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+      # In that case, +options+ and the block will be used by #create_table except if you provide more than one table which is not supported.
+      def drop_table(*table_names, **options)
+        table_names.each { |table_name| schema_cache.clear_data_source_cache!(table_name.to_s) }
+        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE#{' IF EXISTS' if options[:if_exists]} #{table_names.map { |table_name| quote_table_name(table_name) }.join(', ')}#{' CASCADE' if options[:force] == :cascade}"
       end
 
       def rename_index(table_name, old_name, new_name)
@@ -414,7 +407,11 @@ module ActiveRecord
         type ||= column.sql_type
 
         unless options.key?(:default)
-          options[:default] = column.default
+          options[:default] = if column.default_function
+            -> { column.default_function }
+          else
+            column.default
+          end
         end
 
         unless options.key?(:null)
@@ -580,7 +577,7 @@ module ActiveRecord
 
       # SHOW VARIABLES LIKE 'name'
       def show_variable(name)
-        query_value("SELECT @@#{name}", "SCHEMA")
+        query_value("SELECT @@#{name}", "SCHEMA", materialize_transactions: false, allow_retry: true)
       rescue ActiveRecord::StatementInvalid
         nil
       end
@@ -639,24 +636,26 @@ module ActiveRecord
       end
 
       def build_insert_sql(insert) # :nodoc:
+        # Can use any column as it will be assigned to itself.
         no_op_column = quote_column_name(insert.keys.first) if insert.keys.first
 
         # MySQL 8.0.19 replaces `VALUES(<expression>)` clauses with row and column alias names, see https://dev.mysql.com/worklog/task/?id=6312 .
         # then MySQL 8.0.20 deprecates the `VALUES(<expression>)` see https://dev.mysql.com/worklog/task/?id=13325 .
         if supports_insert_raw_alias_syntax?
+          quoted_table_name = insert.model.quoted_table_name
           values_alias = quote_table_name("#{insert.model.table_name.parameterize}_values")
           sql = +"INSERT #{insert.into} #{insert.values_list} AS #{values_alias}"
 
           if insert.skip_duplicates?
             if no_op_column
-              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{values_alias}.#{no_op_column}"
+              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{quoted_table_name}.#{no_op_column}"
             end
           elsif insert.update_duplicates?
             if insert.raw_update_sql?
               sql = +"INSERT #{insert.into} #{insert.values_list} ON DUPLICATE KEY UPDATE #{insert.raw_update_sql}"
             else
               sql << " ON DUPLICATE KEY UPDATE "
-              sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column}<=>#{values_alias}.#{column}" }
+              sql << insert.touch_model_timestamps_unless { |column| "#{quoted_table_name}.#{column}<=>#{values_alias}.#{column}" }
               sql << insert.updatable_columns.map { |column| "#{column}=#{values_alias}.#{column}" }.join(",")
             end
           end
@@ -683,8 +682,8 @@ module ActiveRecord
       end
 
       def check_version # :nodoc:
-        if database_version < "5.5.8"
-          raise DatabaseVersionError, "Your version of MySQL (#{database_version}) is too old. Active Record supports MySQL >= 5.5.8."
+        if database_version < "5.6.4"
+          raise DatabaseVersionError, "Your version of MySQL (#{database_version}) is too old. Active Record supports MySQL >= 5.6.4."
         end
       end
 
@@ -757,9 +756,7 @@ module ActiveRecord
 
       private
         def strip_whitespace_characters(expression)
-          expression = expression.gsub(/\\n|\\\\/, "")
-          expression = expression.gsub(/\s{2,}/, " ")
-          expression
+          expression.gsub('\\\n', "").gsub("x0A", "").squish
         end
 
         def extended_type_map_key
@@ -773,7 +770,6 @@ module ActiveRecord
         def handle_warnings(sql)
           return if ActiveRecord.db_warnings_action.nil? || @raw_connection.warning_count == 0
 
-          @affected_rows_before_warnings = @raw_connection.affected_rows
           warning_count = @raw_connection.warning_count
           result = @raw_connection.query("SHOW WARNINGS")
           result = [
@@ -791,11 +787,6 @@ module ActiveRecord
           warning.level == "Note" || super
         end
 
-        # Make sure we carry over any changes to ActiveRecord.default_timezone that have been
-        # made since we established the connection
-        def sync_timezone_changes(raw_connection)
-        end
-
         # See https://dev.mysql.com/doc/mysql-errors/en/server-error-reference.html
         ER_DB_CREATE_EXISTS     = 1007
         ER_FILSORT_ABORT        = 1028
@@ -965,13 +956,11 @@ module ActiveRecord
           end.join(", ")
 
           # ...and send them all in one query
-          internal_execute("SET #{encoding} #{sql_mode_assignment} #{variable_assignments}")
+          raw_execute("SET #{encoding} #{sql_mode_assignment} #{variable_assignments}", "SCHEMA")
         end
 
         def column_definitions(table_name) # :nodoc:
-          execute_and_free("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
-            each_hash(result)
-          end
+          internal_exec_query("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}", "SCHEMA")
         end
 
         def create_table_info(table_name) # :nodoc:

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

@@ -77,14 +77,6 @@ module ActiveRecord
           0
         end
 
-        def quoted_date(value)
-          if supports_datetime_with_precision?
-            super
-          else
-            super.sub(/\.\d{6}\z/, "")
-          end
-        end
-
         def quoted_binary(value)
           "x'#{value.hex}'"
         end
@@ -110,7 +102,13 @@ module ActiveRecord
             else
               value.getlocal
             end
-          when Date, Time
+          when Time
+            if default_timezone == :utc
+              value.utc? ? value : value.getutc
+            else
+              value.utc? ? value.getlocal : value
+            end
+          when Date
             value
           else
             super

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

@@ -42,18 +42,12 @@ module ActiveRecord
         # :method: unsigned_bigint
         # :call-seq: unsigned_bigint(*names, **options)
 
-        ##
-        # :method: unsigned_float
-        # :call-seq: unsigned_float(*names, **options)
-
-        ##
-        # :method: unsigned_decimal
-        # :call-seq: unsigned_decimal(*names, **options)
-
         included do
           define_column_methods :blob, :tinyblob, :mediumblob, :longblob,
             :tinytext, :mediumtext, :longtext, :unsigned_integer, :unsigned_bigint,
             :unsigned_float, :unsigned_decimal
+
+          deprecate :unsigned_float, :unsigned_decimal, deprecator: ActiveRecord.deprecator
         end
       end
 

data/lib/active_record/connection_adapters/mysql/schema_statements.rb

@@ -8,45 +8,43 @@ module ActiveRecord
         def indexes(table_name)
           indexes = []
           current_index = nil
-          execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
-            each_hash(result) do |row|
-              if current_index != row[:Key_name]
-                next if row[:Key_name] == "PRIMARY" # skip the primary key
-                current_index = row[:Key_name]
-
-                mysql_index_type = row[:Index_type].downcase.to_sym
-                case mysql_index_type
-                when :fulltext, :spatial
-                  index_type = mysql_index_type
-                when :btree, :hash
-                  index_using = mysql_index_type
-                end
-
-                indexes << [
-                  row[:Table],
-                  row[:Key_name],
-                  row[:Non_unique].to_i == 0,
-                  [],
-                  lengths: {},
-                  orders: {},
-                  type: index_type,
-                  using: index_using,
-                  comment: row[:Index_comment].presence
-                ]
+          internal_exec_query("SHOW KEYS FROM #{quote_table_name(table_name)}", "SCHEMA").each do |row|
+            if current_index != row["Key_name"]
+              next if row["Key_name"] == "PRIMARY" # skip the primary key
+              current_index = row["Key_name"]
+
+              mysql_index_type = row["Index_type"].downcase.to_sym
+              case mysql_index_type
+              when :fulltext, :spatial
+                index_type = mysql_index_type
+              when :btree, :hash
+                index_using = mysql_index_type
               end
 
-              if row[:Expression]
-                expression = row[:Expression].gsub("\\'", "'")
-                expression = +"(#{expression})" unless expression.start_with?("(")
-                indexes.last[-2] << expression
-                indexes.last[-1][:expressions] ||= {}
-                indexes.last[-1][:expressions][expression] = expression
-                indexes.last[-1][:orders][expression] = :desc if row[:Collation] == "D"
-              else
-                indexes.last[-2] << row[:Column_name]
-                indexes.last[-1][:lengths][row[:Column_name]] = row[:Sub_part].to_i if row[:Sub_part]
-                indexes.last[-1][:orders][row[:Column_name]] = :desc if row[:Collation] == "D"
-              end
+              indexes << [
+                row["Table"],
+                row["Key_name"],
+                row["Non_unique"].to_i == 0,
+                [],
+                lengths: {},
+                orders: {},
+                type: index_type,
+                using: index_using,
+                comment: row["Index_comment"].presence
+              ]
+            end
+
+            if expression = row["Expression"]
+              expression = expression.gsub("\\'", "'")
+              expression = +"(#{expression})" unless expression.start_with?("(")
+              indexes.last[-2] << expression
+              indexes.last[-1][:expressions] ||= {}
+              indexes.last[-1][:expressions][expression] = expression
+              indexes.last[-1][:orders][expression] = :desc if row["Collation"] == "D"
+            else
+              indexes.last[-2] << row["Column_name"]
+              indexes.last[-1][:lengths][row["Column_name"]] = row["Sub_part"].to_i if row["Sub_part"]
+              indexes.last[-1][:orders][row["Column_name"]] = :desc if row["Collation"] == "D"
             end
           end
 
@@ -87,6 +85,13 @@ module ActiveRecord
           super
         end
 
+        def remove_foreign_key(from_table, to_table = nil, **options)
+          # RESTRICT is by default in MySQL.
+          options.delete(:on_update) if options[:on_update] == :restrict
+          options.delete(:on_delete) if options[:on_delete] == :restrict
+          super
+        end
+
         def internal_string_options_for_primary_key
           super.tap do |options|
             if !row_format_dynamic_by_default? && CHARSETS_OF_4BYTES_MAXLEN.include?(charset)
@@ -182,12 +187,12 @@ module ActiveRecord
           end
 
           def new_column_from_field(table_name, field, _definitions)
-            field_name = field.fetch(:Field)
-            type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
-            default, default_function = field[:Default], nil
+            field_name = field.fetch("Field")
+            type_metadata = fetch_type_metadata(field["Type"], field["Extra"])
+            default, default_function = field["Default"], nil
 
             if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
-              default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field[:Extra])
+              default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field["Extra"])
               default, default_function = nil, default
             elsif type_metadata.extra == "DEFAULT_GENERATED"
               default = +"(#{default})" unless default.start_with?("(")
@@ -203,13 +208,13 @@ module ActiveRecord
             end
 
             MySQL::Column.new(
-              field[:Field],
+              field["Field"],
               default,
               type_metadata,
-              field[:Null] == "YES",
+              field["Null"] == "YES",
               default_function,
-              collation: field[:Collation],
-              comment: field[:Comment].presence
+              collation: field["Collation"],
+              comment: field["Comment"].presence
             )
           end
 

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

@@ -13,49 +13,10 @@ module ActiveRecord
           end
         end
 
-        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false) # :nodoc:
-          if without_prepared_statement?(binds)
-            execute_and_free(sql, name, async: async, allow_retry: allow_retry) do |result|
-              if result
-                build_result(columns: result.fields, rows: result.to_a)
-              else
-                build_result(columns: [], rows: [])
-              end
-            end
-          else
-            exec_stmt_and_free(sql, name, binds, cache_stmt: prepare, async: async) do |_, result|
-              if result
-                build_result(columns: result.fields, rows: result.to_a)
-              else
-                build_result(columns: [], rows: [])
-              end
-            end
-          end
-        end
-
-        def exec_delete(sql, name = nil, binds = []) # :nodoc:
-          if without_prepared_statement?(binds)
-            with_raw_connection do |conn|
-              @affected_rows_before_warnings = nil
-              execute_and_free(sql, name) { @affected_rows_before_warnings || conn.affected_rows }
-            end
-          else
-            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
-          end
-        end
-        alias :exec_update :exec_delete
-
         private
-          def sync_timezone_changes(raw_connection)
-            raw_connection.query_options[:database_timezone] = default_timezone
-          end
-
-          def execute_batch(statements, name = nil)
-            statements = statements.map { |sql| transform_query(sql) }
+          def execute_batch(statements, name = nil, **kwargs)
             combine_multi_statements(statements).each do |statement|
-              with_raw_connection do |conn|
-                raw_execute(statement, name)
-              end
+              raw_execute(statement, name, batch: true, **kwargs)
             end
           end
 
@@ -77,73 +38,102 @@ module ActiveRecord
             end
           end
 
-          def with_multi_statements
-            if multi_statements_enabled?
-              return yield
+          def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch: false)
+            reset_multi_statement = if batch && !multi_statements_enabled?
+              raw_connection.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
+              true
             end
 
-            with_raw_connection do |conn|
-              conn.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
+            # Make sure we carry over any changes to ActiveRecord.default_timezone that have been
+            # made since we established the connection
+            raw_connection.query_options[:database_timezone] = default_timezone
 
-              yield
-            ensure
-              conn.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
-            end
-          end
+            result = nil
+            if binds.nil? || binds.empty?
+              ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                result = raw_connection.query(sql)
+                # Ref: https://github.com/brianmario/mysql2/pull/1383
+                # As of mysql2 0.5.6 `#affected_rows` might raise Mysql2::Error if a prepared statement
+                # from that same connection was GCed while `#query` released the GVL.
+                # By avoiding to call `#affected_rows` when we have a result, we reduce the likeliness
+                # of hitting the bug.
+                @affected_rows_before_warnings = result&.size || raw_connection.affected_rows
+              end
+            elsif prepare
+              stmt = @statements[sql] ||= raw_connection.prepare(sql)
+              begin
+                ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                  result = stmt.execute(*type_casted_binds)
+                  @affected_rows_before_warnings = stmt.affected_rows
+                end
+              rescue ::Mysql2::Error
+                @statements.delete(sql)
+                raise
+              end
+            else
+              stmt = raw_connection.prepare(sql)
+
+              begin
+                ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                  result = stmt.execute(*type_casted_binds)
+                  @affected_rows_before_warnings = stmt.affected_rows
+                end
 
-          def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-            log(sql, name, async: async) do |notification_payload|
-              with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
-                sync_timezone_changes(conn)
-                result = conn.query(sql)
-                conn.abandon_results!
-                verified!
-                handle_warnings(sql)
-                notification_payload[:row_count] = result&.size || 0
-                result
+                # Ref: https://github.com/brianmario/mysql2/pull/1383
+                # by eagerly closing uncached prepared statements, we also reduce the chances of
+                # that bug happening. It can still happen if `#execute` is used as we have no callback
+                # to eagerly close the statement.
+                if result
+                  result.instance_variable_set(:@_ar_stmt_to_close, stmt)
+                else
+                  stmt.close
+                end
+              rescue ::Mysql2::Error
+                stmt.close
+                raise
               end
             end
+
+            notification_payload[:affected_rows] = @affected_rows_before_warnings
+            notification_payload[:row_count] = result&.size || 0
+
+            raw_connection.abandon_results!
+
+            verified!
+            handle_warnings(sql)
+            result
+          ensure
+            if reset_multi_statement && active?
+              raw_connection.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+            end
           end
 
-          def exec_stmt_and_free(sql, name, binds, cache_stmt: false, async: false)
-            sql = transform_query(sql)
-            check_if_write_query(sql)
+          def cast_result(raw_result)
+            return ActiveRecord::Result.empty if raw_result.nil?
 
-            mark_transaction_written_if_write(sql)
+            fields = raw_result.fields
 
-            type_casted_binds = type_casted_binds(binds)
+            result = if fields.empty?
+              ActiveRecord::Result.empty
+            else
+              ActiveRecord::Result.new(fields, raw_result.to_a)
+            end
 
-            log(sql, name, binds, type_casted_binds, async: async) do |notification_payload|
-              with_raw_connection do |conn|
-                sync_timezone_changes(conn)
+            free_raw_result(raw_result)
 
-                if cache_stmt
-                  stmt = @statements[sql] ||= conn.prepare(sql)
-                else
-                  stmt = conn.prepare(sql)
-                end
+            result
+          end
 
-                begin
-                  result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                    stmt.execute(*type_casted_binds)
-                  end
-                  verified!
-                  result
-                rescue ::Mysql2::Error => e
-                  if cache_stmt
-                    @statements.delete(sql)
-                  else
-                    stmt.close
-                  end
-                  raise e
-                end
+          def affected_rows(raw_result)
+            free_raw_result(raw_result) if raw_result
 
-                ret = yield stmt, result
-                notification_payload[:row_count] = result&.size || 0
-                result.free if result
-                stmt.close unless cache_stmt
-                ret
-              end
+            @affected_rows_before_warnings
+          end
+
+          def free_raw_result(raw_result)
+            raw_result.free
+            if stmt = raw_result.instance_variable_get(:@_ar_stmt_to_close)
+              stmt.close
             end
           end
       end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -55,6 +55,7 @@ module ActiveRecord
       def initialize(...)
         super
 
+        @affected_rows_before_warnings = nil
         @config[:flags] ||= 0
 
         if @config[:flags].kind_of? Array
@@ -92,14 +93,6 @@ module ActiveRecord
 
       # HELPER METHODS ===========================================
 
-      def each_hash(result, &block) # :nodoc:
-        if block_given?
-          result.each(as: :hash, symbolize_keys: true, &block)
-        else
-          to_enum(:each_hash, result)
-        end
-      end
-
       def error_number(exception)
         exception.error_number if exception.respond_to?(:error_number)
       end
@@ -113,7 +106,14 @@ module ActiveRecord
       end
 
       def active?
-        connected? && @lock.synchronize { @raw_connection&.ping } || false
+        if connected?
+          @lock.synchronize do
+            if @raw_connection&.ping
+              verified!
+              true
+            end
+          end
+        end || false
       end
 
       alias :reset! :reconnect!