Class: ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 29

class_attribute :emulate_booleans, default: true

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 664

def extended_type_map(default_timezone: nil, emulate_booleans:) # :nodoc:
  super(default_timezone: default_timezone).tap do |m|
    if emulate_booleans
      m.register_type %r(^tinyint\(1\))i, Type::Boolean.new
    end
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 711

def extract_precision(sql_type)
  if /\A(?:date)?time(?:stamp)?\b/.match?(sql_type)
    super || 0
  else
    super
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 673

def initialize_type_map(m)
  super

  m.register_type %r(tinytext)i,   Type::Text.new(limit: 2**8 - 1)
  m.register_type %r(tinyblob)i,   Type::Binary.new(limit: 2**8 - 1)
  m.register_type %r(text)i,       Type::Text.new(limit: 2**16 - 1)
  m.register_type %r(blob)i,       Type::Binary.new(limit: 2**16 - 1)
  m.register_type %r(mediumtext)i, Type::Text.new(limit: 2**24 - 1)
  m.register_type %r(mediumblob)i, Type::Binary.new(limit: 2**24 - 1)
  m.register_type %r(longtext)i,   Type::Text.new(limit: 2**32 - 1)
  m.register_type %r(longblob)i,   Type::Binary.new(limit: 2**32 - 1)
  m.register_type %r(^float)i,     Type::Float.new(limit: 24)
  m.register_type %r(^double)i,    Type::Float.new(limit: 53)

  register_integer_type m, %r(^bigint)i,    limit: 8
  register_integer_type m, %r(^int)i,       limit: 4
  register_integer_type m, %r(^mediumint)i, limit: 3
  register_integer_type m, %r(^smallint)i,  limit: 2
  register_integer_type m, %r(^tinyint)i,   limit: 1

  m.alias_type %r(year)i, "integer"
  m.alias_type %r(bit)i,  "binary"

  # AbstractAdapter's generic type map matches POINT and MULTIPOINT against
  # %r(int)i and misreports them as integers, so override them here.
  m.register_type %r(^(?:point|multipoint))i, Type::Value.new
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 91

def native_database_types # :nodoc:
  NATIVE_DATABASE_TYPES
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 701

def register_integer_type(mapping, key, limit:)
  mapping.register_type(key) do |sql_type|
    if /\bunsigned\b/.match?(sql_type)
      Type::UnsignedInteger.new(limit: limit)
    else
      Type::Integer.new(limit: limit)
    end
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 29

class_attribute :emulate_booleans, default: true

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 102

def mariadb? # :nodoc:
  /mariadb/i.match?(full_version)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 571

def strict_mode?
  if @config.key?(:strict) && !@strict_mode_deprecation_warned
    @strict_mode_deprecation_warned = true
    ActiveRecord.deprecator.warn(<<~MSG.squish)
      The `strict` option in database configurations is deprecated and
      will be removed in Rails 9.0. Use `variables: { sql_mode: "..." }`
      to configure sql_mode directly instead.
    MSG
  end

  self.class.type_cast_config_to_boolean(@config.fetch(:strict, true))
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 171

def supports_advisory_locks?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 106

def supports_bulk_alter?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 138

def supports_check_constraints?
  if mariadb?
    database_version >= "10.3.10" || (database_version < "10.3" && database_version >= "10.2.22")
  else
    database_version >= "8.0.16"
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 163

def supports_common_table_expressions?
  if mariadb?
    database_version >= "10.2.1"
  else
    database_version >= "8.0.1"
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 150

def supports_datetime_with_precision?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 193

def supports_disabling_indexes?
  if mariadb?
    database_version >= "10.6.0"
  else
    database_version >= "8.0.0"
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 126

def supports_explain?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 114

def supports_expression_index?
  !mariadb? && database_version >= "8.0.13"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 134

def supports_foreign_keys?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 110

def supports_index_sort_order?
  mariadb? ? database_version >= "10.8.1" : database_version >= "8.0.1"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 130

def supports_indexes_in_create?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 175

def supports_insert_on_duplicate_skip?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 179

def supports_insert_on_duplicate_update?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 981

def supports_insert_raw_alias_syntax?
  !mariadb? && database_version >= "8.0.19"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 183

def supports_insert_returning?
  mariadb? && database_version >= "10.5.0"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 159

def supports_optimizer_hints?
  !mariadb? && database_version >= "5.7.7"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 993

def supports_rename_column?
  if mariadb?
    database_version >= "10.5.2"
  else
    database_version >= "8.0.3"
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 985

def supports_rename_index?
  if mariadb?
    database_version >= "10.5.2"
  else
    database_version >= "5.7.6"
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 122

def supports_restart_db_transaction?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 118

def supports_transaction_isolation?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 146

def supports_views?
  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 154

def supports_virtual_columns?
  mariadb? || database_version >= "5.7.5"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 514

def add_sql_comment!(sql, comment) # :nodoc:
  sql << " COMMENT #{quote(comment)}" if comment.present?
  sql
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1146

def arel_visitor
  Arel::Visitors::MySQL.new(self)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 264

def begin_db_transaction # :nodoc:
  query_command("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 268

def begin_isolated_db_transaction(isolation) # :nodoc:
  # 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
  if multi_statements_enabled?
    execute_batch(
      ["SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "BEGIN"],
      "TRANSACTION",
      allow_retry: true,
      materialize_transactions: false,
    )
  else
    with_raw_connection(allow_retry: true, materialize_transactions: false) do
      query_command(
        "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}",
        "TRANSACTION",
        allow_retry: false,
        materialize_transactions: false,
      )
      query_command("BEGIN", "TRANSACTION", allow_retry: false, materialize_transactions: false)
    end
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 859

def build_check_constraints(table_name, chk_info)
  chk_info.map do |row|
    options = { name: row["name"] }
    expression = row["expression"]
    expression = expression[1..-2] if expression.start_with?("(") && expression.end_with?(")")
    expression = strip_whitespace_characters(expression)

    unless mariadb?
      # MySQL returns check constraints expression in an already escaped form.
      # This leads to duplicate escaping later (e.g. when the expression is used in the SchemaDumper).
      expression = expression.gsub("\\'", "'")
    end

    CheckConstraintDefinition.new(table_name, expression, options)
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 464

def build_create_index_definition(table_name, column_name, **options) # :nodoc:
  lock = lock_clause(options.delete(:lock))
  index, algorithm, if_not_exists = add_index_options(table_name, column_name, **options)

  return if if_not_exists && index_exists?(table_name, column_name, name: index.name)

  CreateIndexDefinition.new(index, algorithm, if_not_exists, lock)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 837

def build_foreign_keys(table_name, fk_info)
  grouped_fk = fk_info.group_by { |row| row["name"] }.values.each { |group| group.sort_by! { |row| row["position"] } }
  grouped_fk.map do |group|
    row = group.first
    options = {
      name: row["name"],
      on_update: extract_foreign_key_action(row["on_update"]),
      on_delete: extract_foreign_key_action(row["on_delete"])
    }

    if group.one?
      options[:column] = unquote_identifier(row["column"])
      options[:primary_key] = row["primary_key"]
    else
      options[:column] = group.map { |row| unquote_identifier(row["column"]) }
      options[:primary_key] = group.map { |row| row["primary_key"] }
    end

    ForeignKeyDefinition.new(table_name, unquote_identifier(row["to_table"]), options)
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 600

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}=#{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| "#{quoted_table_name}.#{column}<=>#{values_alias}.#{column}" }
        sql << insert.updatable_columns.map { |column| "#{column}=#{values_alias}.#{column}" }.join(",")
      end
    end
  else
    sql = +"INSERT #{insert.into} #{insert.values_list}"

    if insert.skip_duplicates?
      if no_op_column
        sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{no_op_column}"
      end
    elsif insert.update_duplicates?
      sql << " ON DUPLICATE KEY UPDATE "
      if insert.raw_update_sql?
        sql << insert.raw_update_sql
      else
        sql << insert.touch_model_timestamps_unless { |column| "#{column}<=>VALUES(#{column})" }
        sql << insert.updatable_columns.map { |column| "#{column}=VALUES(#{column})" }.join(",")
      end
    end
  end

  sql << " RETURNING #{insert.returning}" if insert.returning
  sql
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1150

def build_statement_pool
  StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 730

def build_table_options(table_name, create_table_info)
  # strip create_definitions and partition_options
  # Be aware that `create_table_info` might not include any table options due to `NO_TABLE_OPTIONS` sql mode.
  raw_table_options = create_table_info.sub(/\A.*\n\) ?/m, "").sub(/\n\/\*!.*\*\/\n\z/m, "").strip

  return if raw_table_options.empty?

  table_options = {}

  if / DEFAULT CHARSET=(?<charset>\w+)(?: COLLATE=(?<collation>\w+))?/ =~ raw_table_options
    raw_table_options = $` + $' # before part + after part
    table_options[:charset] = charset
    table_options[:collation] = collation if collation
  end

  # strip AUTO_INCREMENT
  raw_table_options.sub!(/(ENGINE=\w+)(?: AUTO_INCREMENT=\d+)/, '\1')

  # strip COMMENT
  if raw_table_options.sub!(/ COMMENT='.+'/, "")
    table_options[:comment] = table_comment(table_name)
  end

  table_options[:options] = raw_table_options unless raw_table_options == "ENGINE=InnoDB"
  table_options
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 551

def can_perform_case_insensitive_comparison_for?(column)
  column.case_sensitive?
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 541

def case_sensitive_comparison(attribute, value) # :nodoc:
  column = column_for_attribute(attribute)

  if column.collation && !column.case_sensitive?
    attribute.eq(Arel::Nodes::Bin.new(value))
  else
    super
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 444

def change_column(table_name, column_name, type, **options) # :nodoc:
  at = build_alter_table_definition(table_name)
  at.change_column(column_name, type, **options)
  execute_alter_table(at)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 439

def change_column_comment(table_name, column_name, comment_or_changes) # :nodoc:
  comment = extract_new_comment_value(comment_or_changes)
  change_column table_name, column_name, nil, comment: comment
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 423

def change_column_default(table_name, column_name, default_or_changes) # :nodoc:
  at = build_alter_table_definition(table_name)
  at.change_column_default(column_name, default_or_changes)
  execute_alter_table(at)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 429

def change_column_null(table_name, column_name, null, default = nil) # :nodoc:
  validate_change_column_null_argument!(null)

  unless null || default.nil?
    execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
  end

  change_column table_name, column_name, nil, null: null
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 375

def change_table_comment(table_name, comment_or_changes) # :nodoc:
  comment = extract_new_comment_value(comment_or_changes)
  comment = "" if comment.nil?
  execute("ALTER TABLE #{quote_table_name(table_name)} COMMENT #{quote(comment)}")
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 350

def charset
  show_variable "character_set_database"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 524

def check_constraints(table_name)
  result = fetch_check_constraints(Array(table_name).map(&:to_s))
  table_name.is_a?(Array) ? result : result[table_name.to_s]
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 646

def check_version # :nodoc:
  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

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 355

def collation
  show_variable "collation_database"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1064

def column_definitions(table_name) # :nodoc:
  fields = query_all("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}")

  update_fields_for_mariadb(table_name, fields) if mariadb?

  fields
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 560

def columns_for_distinct(columns, orders) # :nodoc:
  order_columns = orders.compact_blank.map { |s|
    # Convert Arel node to string
    s = visitor.compile(s) unless s.is_a?(String)
    # Remove any ASC/DESC modifiers
    s.gsub(/\s+(?:ASC|DESC)\b/i, "")
  }.compact_blank.map.with_index { |column, i| "#{column} AS alias_#{i}" }

  (order_columns << super).join(", ")
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 291

def commit_db_transaction # :nodoc:
  query_command("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1001

def configure_connection
  super
  variables = @config.fetch(:variables, {}).stringify_keys

  # Increase timeout so the server doesn't disconnect us.
  # Set to false in config to skip.
  unless @config[:wait_timeout] == false
    wait_timeout = self.class.type_cast_config_to_integer(@config[:wait_timeout])
    wait_timeout = 2147483 unless wait_timeout.is_a?(Integer)
    variables["wait_timeout"] = wait_timeout
  end

  defaults = [":default", :default].to_set

  # Make MySQL reject illegal values rather than truncating or blanking them, see
  # https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_traditional
  # If the user has provided another value for sql_mode, don't replace it.
  # Set sql_mode to false or :default in variables to skip.
  if variables.key?("sql_mode")
    sql_mode_value = variables.delete("sql_mode")
    unless sql_mode_value == false || defaults.include?(sql_mode_value)
      sql_mode = quote(sql_mode_value)
    end
  elsif !defaults.include?(strict_mode?)
    if strict_mode?
      sql_mode = "CONCAT(@@sql_mode, ',TRADITIONAL')"
    else
      sql_mode = "REPLACE(@@sql_mode, 'STRICT_TRANS_TABLES', '')"
      sql_mode = "REPLACE(#{sql_mode}, 'STRICT_ALL_TABLES', '')"
      sql_mode = "REPLACE(#{sql_mode}, 'TRADITIONAL', '')"
    end
    sql_mode = "CONCAT(#{sql_mode}, ',NO_AUTO_VALUE_ON_ZERO')"
  end
  sql_mode_assignment = "@@SESSION.sql_mode = #{sql_mode}, " if sql_mode

  # NAMES does not have an equals sign, see
  # https://dev.mysql.com/doc/refman/en/set-names.html
  # (trailing comma because variable_assignments will always have content)
  if @config[:encoding]
    encoding = +"NAMES #{@config[:encoding]}"
    encoding << " COLLATE #{@config[:collation]}" if @config[:collation]
    encoding << ", "
  end

  # Gather up all of the SET variables...
  variable_assignments = variables.filter_map do |k, v|
    if defaults.include?(v)
      "@@SESSION.#{k} = DEFAULT" # Sets the value to the global or compile default
    elsif !v.nil?
      "@@SESSION.#{k} = #{quote(v)}"
    end
  end.join(", ")

  # ...and send them all in one query
  intent = QueryIntent.new(
    adapter: self,
    processed_sql: "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}",
    name: "SCHEMA"
  )
  intent.execute!
  intent.finish
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 325

def create_database(name, options = {})
  if options[:collation]
    execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT COLLATE #{quote_table_name(options[:collation])}"
  elsif options[:charset]
    execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT CHARACTER SET #{quote_table_name(options[:charset])}"
  elsif row_format_dynamic_by_default?
    execute "CREATE DATABASE #{quote_table_name(name)} DEFAULT CHARACTER SET `utf8mb4`"
  else
    raise "Configure a supported :charset and ensure innodb_large_prefix is enabled to support indexes on varchar(255) string columns."
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1142

def create_table_info(table_name) # :nodoc:
  query_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 345

def current_database
  query_value("SELECT database()")
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 584

def default_index_type?(index) # :nodoc:
  index.using == :btree || super
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 505

def disable_index(table_name, index_name) # :nodoc:
  raise NotImplementedError unless supports_disabling_indexes?

  query = <<~SQL
    ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{quote_column_name(index_name)} #{mariadb? ? "IGNORED" : "INVISIBLE"}
  SQL
  execute(query)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 249

def disable_referential_integrity # :nodoc:
  old = query_value("SELECT @@FOREIGN_KEY_CHECKS")

  begin
    update("SET FOREIGN_KEY_CHECKS = 0")
    yield
  ensure
    update("SET FOREIGN_KEY_CHECKS = #{old}") if active?
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 341

def drop_database(name) # :nodoc:
  execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 408

def drop_table(*table_names, **options)
  table_names.each { |table_name| schema_cache.clear_data_source_cache!(table_name.to_s) }
  execute drop_table_sql(*table_names, **options)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1202

def drop_table_sql(*table_names, if_exists: nil, force: nil, temporary: nil, **)
  temporary = " TEMPORARY" if temporary
  exists = " IF EXISTS" if if_exists
  quoted_table_names = table_names.map { |table_name| quote_table_name(table_name) }.join(", ")
  cascade = " CASCADE" if force == :cascade

  "DROP#{temporary} TABLE#{exists} #{quoted_table_names}#{cascade}"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 588

def empty_all_tables # :nodoc:
  table_names = tables - [pool.schema_migration.table_name, pool.internal_metadata.table_name]
  return if table_names.empty?

  statements = build_delete_from_statements(table_names)

  # Deleting is generally much faster than truncating in MySQL
  disable_referential_integrity do
    execute_batch(statements, "Delete Tables")
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 303

def empty_insert_statement_value(primary_key = nil) # :nodoc:
  "VALUES ()"
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 496

def enable_index(table_name, index_name) # :nodoc:
  raise NotImplementedError unless supports_disabling_indexes?

  query = <<~SQL
    ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{quote_column_name(index_name)} #{mariadb? ? "NOT IGNORED" : "VISIBLE"}
  SQL
  execute(query)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 243

def error_number(exception) # :nodoc:
  raise NotImplementedError
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 299

def exec_restart_db_transaction # :nodoc:
  query_command("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, materialize_transactions: true)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 295

def exec_rollback_db_transaction # :nodoc:
  query_command("ROLLBACK", "TRANSACTION", allow_retry: false, materialize_transactions: true)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 880

def extended_type_map_key
  if @default_timezone
    { default_timezone: @default_timezone, emulate_booleans: emulate_booleans }
  elsif emulate_booleans
    EMULATE_BOOLEANS_TRUE
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 797

def fetch_check_constraints(tables)
  raise NotImplementedError unless supports_check_constraints?

  fetch_by_schema(tables) do |schema, group|
    names = quoted_table_names(group)

    sql = +<<~SQL
      SELECT tc.table_name AS 'table',
             cc.constraint_name AS 'name',
             cc.check_clause AS 'expression'
      FROM information_schema.check_constraints cc
      JOIN information_schema.table_constraints tc
      USING (constraint_schema, constraint_name)
      WHERE tc.table_schema = #{schema}
        AND tc.table_name IN (#{names})
        AND cc.constraint_schema = #{schema}
    SQL
    sql << " AND cc.table_name IN (#{names})" if mariadb?

    by_name = query_all(sql).group_by { |row| row["table"] }

    group.index_with { |table| build_check_constraints(table, rows_for(by_name, table)) }
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1072

def fetch_column_definitions(tables)
  fetch_by_schema(tables) do |schema, group|
    by_name = query_all(<<~SQL).group_by { |row| row["Table"] }
      SELECT table_name AS 'Table', column_name AS 'Field', column_type AS 'Type',
             column_default AS 'Default', is_nullable AS 'Null', extra AS 'Extra',
             collation_name AS 'Collation', column_comment AS 'Comment'
      FROM information_schema.columns
      WHERE table_schema = #{schema}
        AND table_name IN (#{quoted_table_names(group)})
      ORDER BY table_name, ordinal_position
    SQL

    group.index_with do |table|
      fields = rows_for(by_name, table)

      next column_definitions(table) if fields.empty?

      fields.each { |field| unquote_mariadb_default(field) } if mariadb?

      fields
    end
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 770

def fetch_foreign_keys(tables)
  fetch_by_schema(tables) do |schema, group|
    names = quoted_table_names(group)

    # MySQL returns 1 row for each column of composite foreign keys.
    by_name = query_all(<<~SQL).group_by { |row| row["from_table"] }
      SELECT fk.table_name AS 'from_table',
             fk.referenced_table_name AS 'to_table',
             fk.referenced_column_name AS 'primary_key',
             fk.column_name AS 'column',
             fk.constraint_name AS 'name',
             fk.ordinal_position AS 'position',
             rc.update_rule AS 'on_update',
             rc.delete_rule AS 'on_delete'
      FROM information_schema.referential_constraints rc
      JOIN information_schema.key_column_usage fk
      USING (constraint_schema, constraint_name)
      WHERE fk.referenced_column_name IS NOT NULL
        AND fk.table_schema = #{schema}
        AND rc.constraint_schema = #{schema}
        AND fk.table_name IN (#{names}) AND rc.table_name IN (#{names})
    SQL

    group.index_with { |table| build_foreign_keys(table, rows_for(by_name, table)) }
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 822

def fetch_primary_keys(tables)
  fetch_by_schema(tables) do |schema, group|
    by_name = query_all(<<~SQL).group_by { |row| row["table"] }
      SELECT table_name AS 'table', column_name AS 'column'
      FROM information_schema.statistics
      WHERE index_name = 'PRIMARY'
        AND table_schema = #{schema}
        AND table_name IN (#{quoted_table_names(group)})
      ORDER BY table_name, seq_in_index
    SQL

    group.index_with { |table| rows_for(by_name, table).map { |row| row["column"] } }
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 757

def fetch_table_collations(tables)
  fetch_by_schema(tables) do |schema, group|
    by_name = query_all(<<~SQL).to_h { |row| [row["table"], row["collation"]] }
      SELECT table_name AS 'table', table_collation AS 'collation'
      FROM information_schema.tables
      WHERE table_schema = #{schema}
        AND table_name IN (#{quoted_table_names(group)})
    SQL

    group.index_with { |table| by_name[bare_table_name(table)] }
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 726

def fetch_table_options(tables)
  tables.index_with { |table| build_table_options(table, create_table_info(table)) }
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 519

def foreign_keys(table_name)
  result = fetch_foreign_keys(Array(table_name).map(&:to_s))
  table_name.is_a?(Array) ? result : result[table_name.to_s]
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 201

def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
  query_value("SELECT GET_LOCK(#{quote(lock_name.to_s)}, #{timeout})", nil, materialize_transactions: true) == 1
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 96

def get_database_version # :nodoc:
  full_version_string = get_full_version
  version_string = version_string(full_version_string)
  Version.new(version_string, full_version_string)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 888

def handle_warnings(_initial_result, sql)
  return if ActiveRecord.db_warnings_action.nil? || @raw_connection.warning_count == 0

  warning_count = @raw_connection.warning_count
  result = @raw_connection.query("SHOW WARNINGS")
  result = [
    ["Warning", nil, "Query had warning_count=#{warning_count} but `SHOW WARNINGS` did not return the warnings. Check MySQL logs or database configuration."],
  ] if result.count == 0
  result.each do |level, code, message|
    warning = SQLWarning.new(message, code, level, sql, @pool)
    next if warning_ignored?(warning)

    ActiveRecord.db_warnings_action.call(warning)
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 209

def index_algorithms
  {
    default: "ALGORITHM = DEFAULT",
    copy:    "ALGORITHM = COPY",
    inplace: "ALGORITHM = INPLACE",
    instant: "ALGORITHM = INSTANT",
  }
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 234

def lock_clause(lock) # :nodoc:
  return unless lock
  lock_options.fetch(lock) do
    raise ArgumentError, "Lock must be one of the following: #{lock_options.keys.map(&:inspect).join(', ')}"
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 225

def lock_options
  {
    default:   "LOCK = DEFAULT",
    none:      "LOCK = NONE",
    shared:    "LOCK = SHARED",
    exclusive: "LOCK = EXCLUSIVE",
  }
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1177

def mismatched_foreign_key(message, sql:, binds:, connection_pool:)
  options = {
    message: message,
    sql: sql,
    binds: binds,
    connection_pool: connection_pool
  }

  if sql
    options.update mismatched_foreign_key_details(message: message, sql: sql)
  else
    options[:query_parser] = ->(sql) { mismatched_foreign_key_details(message: message, sql: sql) }
  end

  MismatchedForeignKey.new(**options)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 1154

def mismatched_foreign_key_details(message:, sql:)
  foreign_key_pat =
    /Referencing column '(\w+)' and referenced/i =~ message ? $1 : '\w+'

  match = %r/
    (?:CREATE|ALTER)\sTABLE\s*(?:`?\w`?\.)?`?(?<table>\w)`?.?
    FOREIGN\s+KEY\s*\(`?(?<foreign_key>#{foreign_key_pat})`?\)\s*
    REFERENCES\s*(`?(?<target_table>\w)`?)\s*\(`?(?<primary_key>\w)`?\)
  /xmi.match(sql)

  options = {}

  if match
    options[:table] = match[:table]
    options[:foreign_key] = match[:foreign_key]
    options[:target_table] = match[:target_table]
    options[:primary_key] = match[:primary_key]
    options[:primary_key_column] = column_for(match[:target_table], match[:primary_key])
  end

  options
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 536

def primary_keys(table_name) # :nodoc:
  result = fetch_primary_keys(Array(table_name).map(&:to_s))
  table_name.is_a?(Array) ? result : result[table_name.to_s]
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 657

def quote_string(string)
  with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
    connection.escape(string)
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb', line 311