class ActiveRecord::ConnectionAdapters::MysqlAdapter

def active?
  if @connection.respond_to?(:stat)
    @connection.stat
  else
    @connection.query 'select 1'
  end
  # mysql-ruby doesn't raise an exception when stat fails.
  if @connection.respond_to?(:errno)
    @connection.errno.zero?
  else
    true
  end
rescue Mysql::Error
  false
end

def begin_db_transaction #:nodoc:
  exec_query "BEGIN"
end

def clear_cache!
  super
  @statements.clear
end

def client_encoding
  return @client_encoding if @client_encoding
  result = exec_query(
    "SHOW VARIABLES WHERE Variable_name = 'character_set_client'",
    'SCHEMA')
  @client_encoding = ENCODINGS[result.rows.last.last]
end

def configure_connection
  super
end

def connect
  encoding = @config[:encoding]
  if encoding
    @connection.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
  end
  if @config[:sslca] || @config[:sslkey]
    @connection.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher])
  end
  @connection.options(Mysql::OPT_CONNECT_TIMEOUT, @config[:connect_timeout]) if @config[:connect_timeout]
  @connection.options(Mysql::OPT_READ_TIMEOUT, @config[:read_timeout]) if @config[:read_timeout]
  @connection.options(Mysql::OPT_WRITE_TIMEOUT, @config[:write_timeout]) if @config[:write_timeout]
  @connection.real_connect(*@connection_options)
  # reconnect must be set after real_connect is called, because real_connect sets it to false internally
  @connection.reconnect = !!@config[:reconnect] if @connection.respond_to?(:reconnect=)
  configure_connection
end

def disconnect!
  super
  @connection.close rescue nil
end

def each_hash(result) # :nodoc:
  if block_given?
    result.each_hash do |row|
      row.symbolize_keys!
      yield row
    end
  else
    to_enum(:each_hash, result)
  end
end

def error_number(exception) # :nodoc:
  exception.errno if exception.respond_to?(:errno)
end

def exec_delete(sql, name, binds) # :nodoc:
  affected_rows = 0
  exec_query(sql, name, binds) do |n|
    affected_rows = n
  end
  affected_rows
end

def exec_query(sql, name = 'SQL', binds = [])
  if without_prepared_statement?(binds)
    result_set, affected_rows = exec_without_stmt(sql, name)
  else
    result_set, affected_rows = exec_stmt(sql, name, binds)
  end
  yield affected_rows if block_given?
  result_set
end

def exec_stmt(sql, name, binds)
  cache = {}
  type_casted_binds = binds.map { |col, val|
    [col, type_cast(val, col)]
  }
  log(sql, name, type_casted_binds) do
    if binds.empty?
      stmt = @connection.prepare(sql)
    else
      cache = @statements[sql] ||= {
        :stmt => @connection.prepare(sql)
      }
      stmt = cache[:stmt]
    end
    begin
      stmt.execute(*type_casted_binds.map { |_, val| val })
    rescue Mysql::Error => e
      # Older versions of MySQL leave the prepared statement in a bad
      # place when an error occurs. To support older MySQL versions, we
      # need to close the statement and delete the statement from the
      # cache.
      stmt.close
      @statements.delete sql
      raise e
    end
    cols = nil
    if metadata = stmt.result_metadata
      cols = cache[:cols] ||= metadata.fetch_fields.map { |field|
        field.name
      }
      metadata.free
    end
    result_set = ActiveRecord::Result.new(cols, stmt.to_a) if cols
    affected_rows = stmt.affected_rows
    stmt.free_result
    stmt.close if binds.empty?
    [result_set, affected_rows]
  end
end

def exec_without_stmt(sql, name = 'SQL') # :nodoc:
  # Some queries, like SHOW CREATE TABLE don't work through the prepared
  # statement API. For those queries, we need to use this method. :'(
  log(sql, name) do
    result = @connection.query(sql)
    affected_rows = @connection.affected_rows
    if result
      types = {}
      fields = []
      result.fetch_fields.each { |field|
        field_name = field.name
        fields << field_name
        if field.decimals > 0
          types[field_name] = Type::Decimal.new
        else
          types[field_name] = Fields.find_type field
        end
      }
      result_set = ActiveRecord::Result.new(fields, result.to_a, types)
      result.free
    else
      result_set = ActiveRecord::Result.new([], [])
    end
    [result_set, affected_rows]
  end
end

def execute_and_free(sql, name = nil) # :nodoc:
  result = execute(sql, name)
  ret = yield result
  result.free
  ret
end

def full_version
  @full_version ||= @connection.server_info
end

def initialize(connection, logger, connection_options, config)
  super
  @statements = StatementPool.new(@connection,
                                  self.class.type_cast_config_to_integer(config.fetch(:statement_limit) { 1000 }))
  @client_encoding = nil
  connect
end

def initialize_type_map(m) # :nodoc:
  super
  m.register_type %r(datetime)i, Fields::DateTime.new
  m.register_type %r(time)i,     Fields::Time.new
end

def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
  super sql, name
  id_value || @connection.insert_id
end

def last_inserted_id(result)
  @connection.insert_id
end

def quote_string(string) #:nodoc:
  @connection.quote(string)
end

def reconnect!
  super
  disconnect!
  connect
end

def reset!
  if @connection.respond_to?(:change_user)
    # See http://bugs.mysql.com/bug.php?id=33540 -- the workaround way to
    # reset the connection is to change the user to the same user.
    @connection.change_user(@config[:username], @config[:password], @config[:database])
    configure_connection
  end
end

def select(sql, name = nil, binds = [])
  @connection.query_with_result = true
  rows = super
  @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
  rows
end

def select_rows(sql, name = nil, binds = [])
  @connection.query_with_result = true
  rows = exec_query(sql, name, binds).rows
  @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
  rows
end

def set_field_encoding field_name
  field_name.force_encoding(client_encoding)
  if internal_enc = Encoding.default_internal
    field_name = field_name.encode!(internal_enc)
  end
  field_name
end

def supports_statement_cache?
  true
end