/* automatically generated by rust-bindgen 0.69.4 */

pub const MARIADB_NAMEDPIPE: &[u8; 6] = b"MySQL\0";
pub const MYSQL_SERVICENAME: &[u8; 6] = b"MySql\0";
pub const MYSQL_AUTODETECT_CHARSET_NAME: &[u8; 5] = b"auto\0";
pub const MARIADB_CLIENT_FLAGS: i64 = -4294967296;
pub const MARIADB_CLIENT_PROGRESS: u64 = 4294967296;
pub const MARIADB_CLIENT_RESERVED_1: u64 = 8589934592;
pub const MARIADB_CLIENT_STMT_BULK_OPERATIONS: u64 = 17179869184;
pub const MARIADB_CLIENT_EXTENDED_METADATA: u64 = 34359738368;
pub const MARIADB_CLIENT_CACHE_METADATA: u64 = 68719476736;
pub const MARIADB_CLIENT_SUPPORTED_FLAGS: u64 = 124554051584;
pub const MYSQL_ERRMSG_SIZE: u32 = 512;
pub const MYSQL50_TABLE_NAME_PREFIX: &[u8; 10] = b"#mysql50#\0";
pub const MARIADB_CONNECTION_UNIXSOCKET: u32 = 0;
pub const MARIADB_CONNECTION_TCP: u32 = 1;
pub const MARIADB_CONNECTION_NAMEDPIPE: u32 = 2;
pub const MARIADB_CONNECTION_SHAREDMEM: u32 = 3;
pub const MARIADB_CLIENT_VERSION_STR: &[u8; 8] = b"10.11.6\0";
pub const MARIADB_BASE_VERSION: &[u8; 14] = b"mariadb-10.11\0";
pub const MARIADB_VERSION_ID: u32 = 101106;
pub const MARIADB_PORT: u32 = 3306;
pub const MARIADB_UNIX_ADDR: &[u8; 24] = b"/run/mysqld/mysqld.sock\0";
pub const MYSQL_UNIX_ADDR: &[u8; 24] = b"/run/mysqld/mysqld.sock\0";
pub const MYSQL_PORT: u32 = 3306;
pub const MYSQL_CONFIG_NAME: &[u8; 3] = b"my\0";
pub const MYSQL_VERSION_ID: u32 = 101106;
pub const MYSQL_SERVER_VERSION: &[u8; 16] = b"10.11.6-MariaDB\0";
pub const MARIADB_PACKAGE_VERSION: &[u8; 6] = b"3.3.8\0";
pub const MARIADB_PACKAGE_VERSION_ID: u32 = 30308;
pub const MARIADB_SYSTEM_TYPE: &[u8; 6] = b"Linux\0";
pub const MARIADB_MACHINE_TYPE: &[u8; 7] = b"x86_64\0";
pub const MARIADB_PLUGINDIR: &[u8; 45] = b"/usr/lib/x86_64-linux-gnu/libmariadb3/plugin\0";
pub const MYSQL_CHARSET: &[u8; 1] = b"\0";
pub const MARIADB_INVALID_SOCKET: i32 = -1;
pub const MYSQL_WAIT_READ: u32 = 1;
pub const MYSQL_WAIT_WRITE: u32 = 2;
pub const MYSQL_WAIT_EXCEPT: u32 = 4;
pub const MYSQL_WAIT_TIMEOUT: u32 = 8;
pub const MYSQL_NO_DATA: u32 = 100;
pub const MYSQL_DATA_TRUNCATED: u32 = 101;
pub const MYSQL_PS_SKIP_RESULT_W_LEN: i32 = -1;
pub const MYSQL_PS_SKIP_RESULT_STR: i32 = -2;
pub type va_list = __builtin_va_list;
pub type my_bool = ::std::os::raw::c_char;
pub type my_ulonglong = ::std::os::raw::c_ulonglong;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum mysql_enum_shutdown_level {
    SHUTDOWN_DEFAULT = 0,
    KILL_QUERY = 254,
    KILL_CONNECTION = 255,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum enum_server_command {
    COM_SLEEP = 0,
    COM_QUIT = 1,
    COM_INIT_DB = 2,
    COM_QUERY = 3,
    COM_FIELD_LIST = 4,
    COM_CREATE_DB = 5,
    COM_DROP_DB = 6,
    COM_REFRESH = 7,
    COM_SHUTDOWN = 8,
    COM_STATISTICS = 9,
    COM_PROCESS_INFO = 10,
    COM_CONNECT = 11,
    COM_PROCESS_KILL = 12,
    COM_DEBUG = 13,
    COM_PING = 14,
    COM_TIME = 15,
    COM_DELAYED_INSERT = 16,
    COM_CHANGE_USER = 17,
    COM_BINLOG_DUMP = 18,
    COM_TABLE_DUMP = 19,
    COM_CONNECT_OUT = 20,
    COM_REGISTER_SLAVE = 21,
    COM_STMT_PREPARE = 22,
    COM_STMT_EXECUTE = 23,
    COM_STMT_SEND_LONG_DATA = 24,
    COM_STMT_CLOSE = 25,
    COM_STMT_RESET = 26,
    COM_SET_OPTION = 27,
    COM_STMT_FETCH = 28,
    COM_DAEMON = 29,
    COM_UNSUPPORTED = 30,
    COM_RESET_CONNECTION = 31,
    COM_STMT_BULK_EXECUTE = 250,
    COM_RESERVED_1 = 254,
    COM_END = 255,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_ma_pvio {
    _unused: [u8; 0],
}
pub type MARIADB_PVIO = st_ma_pvio;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_net {
    pub pvio: *mut MARIADB_PVIO,
    pub buff: *mut ::std::os::raw::c_uchar,
    pub buff_end: *mut ::std::os::raw::c_uchar,
    pub write_pos: *mut ::std::os::raw::c_uchar,
    pub read_pos: *mut ::std::os::raw::c_uchar,
    pub fd: ::std::os::raw::c_uint,
    pub remain_in_buf: ::std::os::raw::c_ulong,
    pub length: ::std::os::raw::c_ulong,
    pub buf_length: ::std::os::raw::c_ulong,
    pub where_b: ::std::os::raw::c_ulong,
    pub max_packet: ::std::os::raw::c_ulong,
    pub max_packet_size: ::std::os::raw::c_ulong,
    pub pkt_nr: ::std::os::raw::c_uint,
    pub compress_pkt_nr: ::std::os::raw::c_uint,
    pub write_timeout: ::std::os::raw::c_uint,
    pub read_timeout: ::std::os::raw::c_uint,
    pub retry_count: ::std::os::raw::c_uint,
    pub fcntl: ::std::os::raw::c_int,
    pub return_status: *mut ::std::os::raw::c_uint,
    pub reading_or_writing: ::std::os::raw::c_uchar,
    pub save_char: ::std::os::raw::c_char,
    pub unused_1: ::std::os::raw::c_char,
    pub unused_2: my_bool,
    pub compress: my_bool,
    pub unused_3: my_bool,
    pub unused_4: *mut ::std::os::raw::c_void,
    pub last_errno: ::std::os::raw::c_uint,
    pub error: ::std::os::raw::c_uchar,
    pub unused_5: my_bool,
    pub unused_6: my_bool,
    pub last_error: [::std::os::raw::c_char; 512usize],
    pub sqlstate: [::std::os::raw::c_char; 6usize],
    pub extension: *mut st_mariadb_net_extension,
}
#[test]
fn bindgen_test_layout_st_net() {
    const UNINIT: ::std::mem::MaybeUninit<st_net> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_net>(),
        620usize,
        concat!("Size of: ", stringify!(st_net))
    );
    assert_eq!(
        ::std::mem::align_of::<st_net>(),
        4usize,
        concat!("Alignment of ", stringify!(st_net))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pvio) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(pvio)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buff) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(buff)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buff_end) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(buff_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).write_pos) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(write_pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).read_pos) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(read_pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(fd)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).remain_in_buf) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(remain_in_buf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buf_length) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(buf_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).where_b) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(where_b)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_packet) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(max_packet)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_packet_size) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(max_packet_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pkt_nr) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(pkt_nr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).compress_pkt_nr) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(compress_pkt_nr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).write_timeout) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(write_timeout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).read_timeout) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(read_timeout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).retry_count) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(retry_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fcntl) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(fcntl)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).return_status) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(return_status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reading_or_writing) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(reading_or_writing)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).save_char) as usize - ptr as usize },
        77usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(save_char)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_1) as usize - ptr as usize },
        78usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(unused_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_2) as usize - ptr as usize },
        79usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(unused_2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).compress) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(compress)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_3) as usize - ptr as usize },
        81usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(unused_3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_4) as usize - ptr as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(unused_4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_errno) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(last_errno)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_5) as usize - ptr as usize },
        93usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(unused_5)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_6) as usize - ptr as usize },
        94usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(unused_6)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_error) as usize - ptr as usize },
        95usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(last_error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sqlstate) as usize - ptr as usize },
        607usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(sqlstate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        616usize,
        concat!(
            "Offset of field: ",
            stringify!(st_net),
            "::",
            stringify!(extension)
        )
    );
}
pub type NET = st_net;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum enum_mysql_set_option {
    MYSQL_OPTION_MULTI_STATEMENTS_ON = 0,
    MYSQL_OPTION_MULTI_STATEMENTS_OFF = 1,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum enum_session_state_type {
    SESSION_TRACK_SYSTEM_VARIABLES = 0,
    SESSION_TRACK_SCHEMA = 1,
    SESSION_TRACK_STATE_CHANGE = 2,
    SESSION_TRACK_GTIDS = 3,
    SESSION_TRACK_TRANSACTION_CHARACTERISTICS = 4,
    SESSION_TRACK_TRANSACTION_STATE = 5,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum enum_field_types {
    MYSQL_TYPE_DECIMAL = 0,
    MYSQL_TYPE_TINY = 1,
    MYSQL_TYPE_SHORT = 2,
    MYSQL_TYPE_LONG = 3,
    MYSQL_TYPE_FLOAT = 4,
    MYSQL_TYPE_DOUBLE = 5,
    MYSQL_TYPE_NULL = 6,
    MYSQL_TYPE_TIMESTAMP = 7,
    MYSQL_TYPE_LONGLONG = 8,
    MYSQL_TYPE_INT24 = 9,
    MYSQL_TYPE_DATE = 10,
    MYSQL_TYPE_TIME = 11,
    MYSQL_TYPE_DATETIME = 12,
    MYSQL_TYPE_YEAR = 13,
    MYSQL_TYPE_NEWDATE = 14,
    MYSQL_TYPE_VARCHAR = 15,
    MYSQL_TYPE_BIT = 16,
    MYSQL_TYPE_TIMESTAMP2 = 17,
    MYSQL_TYPE_DATETIME2 = 18,
    MYSQL_TYPE_TIME2 = 19,
    MYSQL_TYPE_JSON = 245,
    MYSQL_TYPE_NEWDECIMAL = 246,
    MYSQL_TYPE_ENUM = 247,
    MYSQL_TYPE_SET = 248,
    MYSQL_TYPE_TINY_BLOB = 249,
    MYSQL_TYPE_MEDIUM_BLOB = 250,
    MYSQL_TYPE_LONG_BLOB = 251,
    MYSQL_TYPE_BLOB = 252,
    MYSQL_TYPE_VAR_STRING = 253,
    MYSQL_TYPE_STRING = 254,
    MYSQL_TYPE_GEOMETRY = 255,
    MAX_NO_FIELD_TYPES = 256,
}
extern "C" {
    pub fn mariadb_load_defaults(
        conf_file: *const ::std::os::raw::c_char,
        groups: *mut *const ::std::os::raw::c_char,
        argc: *mut ::std::os::raw::c_int,
        argv: *mut *mut *mut ::std::os::raw::c_char,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_list {
    pub prev: *mut st_list,
    pub next: *mut st_list,
    pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_st_list() {
    const UNINIT: ::std::mem::MaybeUninit<st_list> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_list>(),
        12usize,
        concat!("Size of: ", stringify!(st_list))
    );
    assert_eq!(
        ::std::mem::align_of::<st_list>(),
        4usize,
        concat!("Alignment of ", stringify!(st_list))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_list),
            "::",
            stringify!(prev)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_list),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_list),
            "::",
            stringify!(data)
        )
    );
}
pub type LIST = st_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ma_charset_info_st {
    pub nr: ::std::os::raw::c_uint,
    pub state: ::std::os::raw::c_uint,
    pub csname: *const ::std::os::raw::c_char,
    pub name: *const ::std::os::raw::c_char,
    pub dir: *const ::std::os::raw::c_char,
    pub codepage: ::std::os::raw::c_uint,
    pub encoding: *const ::std::os::raw::c_char,
    pub char_minlen: ::std::os::raw::c_uint,
    pub char_maxlen: ::std::os::raw::c_uint,
    pub mb_charlen: ::std::option::Option<
        unsafe extern "C" fn(c: ::std::os::raw::c_uint) -> ::std::os::raw::c_uint,
    >,
    pub mb_valid: ::std::option::Option<
        unsafe extern "C" fn(
            start: *const ::std::os::raw::c_char,
            end: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_uint,
    >,
}
#[test]
fn bindgen_test_layout_ma_charset_info_st() {
    const UNINIT: ::std::mem::MaybeUninit<ma_charset_info_st> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<ma_charset_info_st>(),
        44usize,
        concat!("Size of: ", stringify!(ma_charset_info_st))
    );
    assert_eq!(
        ::std::mem::align_of::<ma_charset_info_st>(),
        4usize,
        concat!("Alignment of ", stringify!(ma_charset_info_st))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(nr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).csname) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(csname)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dir) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(dir)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).codepage) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(codepage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(encoding)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_minlen) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(char_minlen)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_maxlen) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(char_maxlen)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mb_charlen) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(mb_charlen)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mb_valid) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(ma_charset_info_st),
            "::",
            stringify!(mb_valid)
        )
    );
}
pub type MARIADB_CHARSET_INFO = ma_charset_info_st;
extern "C" {
    pub fn mysql_cset_escape_quotes(
        cset: *const MARIADB_CHARSET_INFO,
        newstr: *mut ::std::os::raw::c_char,
        escapestr: *const ::std::os::raw::c_char,
        escapestr_len: usize,
    ) -> usize;
}
extern "C" {
    pub fn mysql_cset_escape_slashes(
        cset: *const MARIADB_CHARSET_INFO,
        newstr: *mut ::std::os::raw::c_char,
        escapestr: *const ::std::os::raw::c_char,
        escapestr_len: usize,
    ) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_ma_const_string {
    pub str_: *const ::std::os::raw::c_char,
    pub length: usize,
}
#[test]
fn bindgen_test_layout_st_ma_const_string() {
    const UNINIT: ::std::mem::MaybeUninit<st_ma_const_string> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_ma_const_string>(),
        8usize,
        concat!("Size of: ", stringify!(st_ma_const_string))
    );
    assert_eq!(
        ::std::mem::align_of::<st_ma_const_string>(),
        4usize,
        concat!("Alignment of ", stringify!(st_ma_const_string))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_const_string),
            "::",
            stringify!(str_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_const_string),
            "::",
            stringify!(length)
        )
    );
}
pub type MARIADB_CONST_STRING = st_ma_const_string;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_ma_const_data {
    pub data: *const ::std::os::raw::c_uchar,
    pub length: usize,
}
#[test]
fn bindgen_test_layout_st_ma_const_data() {
    const UNINIT: ::std::mem::MaybeUninit<st_ma_const_data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_ma_const_data>(),
        8usize,
        concat!("Size of: ", stringify!(st_ma_const_data))
    );
    assert_eq!(
        ::std::mem::align_of::<st_ma_const_data>(),
        4usize,
        concat!("Alignment of ", stringify!(st_ma_const_data))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_const_data),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_const_data),
            "::",
            stringify!(length)
        )
    );
}
pub type MARIADB_CONST_DATA = st_ma_const_data;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_ma_used_mem {
    pub next: *mut st_ma_used_mem,
    pub left: usize,
    pub size: usize,
}
#[test]
fn bindgen_test_layout_st_ma_used_mem() {
    const UNINIT: ::std::mem::MaybeUninit<st_ma_used_mem> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_ma_used_mem>(),
        12usize,
        concat!("Size of: ", stringify!(st_ma_used_mem))
    );
    assert_eq!(
        ::std::mem::align_of::<st_ma_used_mem>(),
        4usize,
        concat!("Alignment of ", stringify!(st_ma_used_mem))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_used_mem),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_used_mem),
            "::",
            stringify!(left)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_used_mem),
            "::",
            stringify!(size)
        )
    );
}
pub type MA_USED_MEM = st_ma_used_mem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_ma_mem_root {
    pub free: *mut MA_USED_MEM,
    pub used: *mut MA_USED_MEM,
    pub pre_alloc: *mut MA_USED_MEM,
    pub min_malloc: usize,
    pub block_size: usize,
    pub block_num: ::std::os::raw::c_uint,
    pub first_block_usage: ::std::os::raw::c_uint,
    pub error_handler: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout_st_ma_mem_root() {
    const UNINIT: ::std::mem::MaybeUninit<st_ma_mem_root> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_ma_mem_root>(),
        32usize,
        concat!("Size of: ", stringify!(st_ma_mem_root))
    );
    assert_eq!(
        ::std::mem::align_of::<st_ma_mem_root>(),
        4usize,
        concat!("Alignment of ", stringify!(st_ma_mem_root))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(free)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).used) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(used)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pre_alloc) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(pre_alloc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_malloc) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(min_malloc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).block_size) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(block_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).block_num) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(block_num)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).first_block_usage) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(first_block_usage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error_handler) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_ma_mem_root),
            "::",
            stringify!(error_handler)
        )
    );
}
pub type MA_MEM_ROOT = st_ma_mem_root;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_field {
    pub name: *mut ::std::os::raw::c_char,
    pub org_name: *mut ::std::os::raw::c_char,
    pub table: *mut ::std::os::raw::c_char,
    pub org_table: *mut ::std::os::raw::c_char,
    pub db: *mut ::std::os::raw::c_char,
    pub catalog: *mut ::std::os::raw::c_char,
    pub def: *mut ::std::os::raw::c_char,
    pub length: ::std::os::raw::c_ulong,
    pub max_length: ::std::os::raw::c_ulong,
    pub name_length: ::std::os::raw::c_uint,
    pub org_name_length: ::std::os::raw::c_uint,
    pub table_length: ::std::os::raw::c_uint,
    pub org_table_length: ::std::os::raw::c_uint,
    pub db_length: ::std::os::raw::c_uint,
    pub catalog_length: ::std::os::raw::c_uint,
    pub def_length: ::std::os::raw::c_uint,
    pub flags: ::std::os::raw::c_uint,
    pub decimals: ::std::os::raw::c_uint,
    pub charsetnr: ::std::os::raw::c_uint,
    pub type_: enum_field_types,
    pub extension: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_st_mysql_field() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_field> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_field>(),
        84usize,
        concat!("Size of: ", stringify!(st_mysql_field))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_field>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_field))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).org_name) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(org_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(table)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).org_table) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(org_table)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(db)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).catalog) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(catalog)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).def) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(def)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_length) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(max_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name_length) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(name_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).org_name_length) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(org_name_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).table_length) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(table_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).org_table_length) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(org_table_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_length) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(db_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).catalog_length) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(catalog_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).def_length) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(def_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).decimals) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(decimals)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).charsetnr) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(charsetnr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_field),
            "::",
            stringify!(extension)
        )
    );
}
pub type MYSQL_FIELD = st_mysql_field;
pub type MYSQL_ROW = *mut *mut ::std::os::raw::c_char;
pub type MYSQL_FIELD_OFFSET = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_rows {
    pub next: *mut st_mysql_rows,
    pub data: MYSQL_ROW,
    pub length: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_st_mysql_rows() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_rows> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_rows>(),
        12usize,
        concat!("Size of: ", stringify!(st_mysql_rows))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_rows>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_rows))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_rows),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_rows),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_rows),
            "::",
            stringify!(length)
        )
    );
}
pub type MYSQL_ROWS = st_mysql_rows;
pub type MYSQL_ROW_OFFSET = *mut MYSQL_ROWS;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_data {
    pub data: *mut MYSQL_ROWS,
    pub embedded_info: *mut ::std::os::raw::c_void,
    pub alloc: MA_MEM_ROOT,
    pub rows: ::std::os::raw::c_ulonglong,
    pub fields: ::std::os::raw::c_uint,
    pub extension: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_st_mysql_data() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_data>(),
        56usize,
        concat!("Size of: ", stringify!(st_mysql_data))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_data>(),
        8usize,
        concat!("Alignment of ", stringify!(st_mysql_data))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_data),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).embedded_info) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_data),
            "::",
            stringify!(embedded_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_data),
            "::",
            stringify!(alloc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rows) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_data),
            "::",
            stringify!(rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fields) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_data),
            "::",
            stringify!(fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_data),
            "::",
            stringify!(extension)
        )
    );
}
pub type MYSQL_DATA = st_mysql_data;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum mysql_option {
    MYSQL_OPT_CONNECT_TIMEOUT = 0,
    MYSQL_OPT_COMPRESS = 1,
    MYSQL_OPT_NAMED_PIPE = 2,
    MYSQL_INIT_COMMAND = 3,
    MYSQL_READ_DEFAULT_FILE = 4,
    MYSQL_READ_DEFAULT_GROUP = 5,
    MYSQL_SET_CHARSET_DIR = 6,
    MYSQL_SET_CHARSET_NAME = 7,
    MYSQL_OPT_LOCAL_INFILE = 8,
    MYSQL_OPT_PROTOCOL = 9,
    MYSQL_SHARED_MEMORY_BASE_NAME = 10,
    MYSQL_OPT_READ_TIMEOUT = 11,
    MYSQL_OPT_WRITE_TIMEOUT = 12,
    MYSQL_OPT_USE_RESULT = 13,
    MYSQL_OPT_USE_REMOTE_CONNECTION = 14,
    MYSQL_OPT_USE_EMBEDDED_CONNECTION = 15,
    MYSQL_OPT_GUESS_CONNECTION = 16,
    MYSQL_SET_CLIENT_IP = 17,
    MYSQL_SECURE_AUTH = 18,
    MYSQL_REPORT_DATA_TRUNCATION = 19,
    MYSQL_OPT_RECONNECT = 20,
    MYSQL_OPT_SSL_VERIFY_SERVER_CERT = 21,
    MYSQL_PLUGIN_DIR = 22,
    MYSQL_DEFAULT_AUTH = 23,
    MYSQL_OPT_BIND = 24,
    MYSQL_OPT_SSL_KEY = 25,
    MYSQL_OPT_SSL_CERT = 26,
    MYSQL_OPT_SSL_CA = 27,
    MYSQL_OPT_SSL_CAPATH = 28,
    MYSQL_OPT_SSL_CIPHER = 29,
    MYSQL_OPT_SSL_CRL = 30,
    MYSQL_OPT_SSL_CRLPATH = 31,
    MYSQL_OPT_CONNECT_ATTR_RESET = 32,
    MYSQL_OPT_CONNECT_ATTR_ADD = 33,
    MYSQL_OPT_CONNECT_ATTR_DELETE = 34,
    MYSQL_SERVER_PUBLIC_KEY = 35,
    MYSQL_ENABLE_CLEARTEXT_PLUGIN = 36,
    MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS = 37,
    MYSQL_OPT_SSL_ENFORCE = 38,
    MYSQL_OPT_MAX_ALLOWED_PACKET = 39,
    MYSQL_OPT_NET_BUFFER_LENGTH = 40,
    MYSQL_OPT_TLS_VERSION = 41,
    MYSQL_PROGRESS_CALLBACK = 5999,
    MYSQL_OPT_NONBLOCK = 6000,
    MYSQL_DATABASE_DRIVER = 7000,
    MARIADB_OPT_SSL_FP = 7001,
    MARIADB_OPT_SSL_FP_LIST = 7002,
    MARIADB_OPT_TLS_PASSPHRASE = 7003,
    MARIADB_OPT_TLS_CIPHER_STRENGTH = 7004,
    MARIADB_OPT_TLS_VERSION = 7005,
    MARIADB_OPT_TLS_PEER_FP = 7006,
    MARIADB_OPT_TLS_PEER_FP_LIST = 7007,
    MARIADB_OPT_CONNECTION_READ_ONLY = 7008,
    MYSQL_OPT_CONNECT_ATTRS = 7009,
    MARIADB_OPT_USERDATA = 7010,
    MARIADB_OPT_CONNECTION_HANDLER = 7011,
    MARIADB_OPT_PORT = 7012,
    MARIADB_OPT_UNIXSOCKET = 7013,
    MARIADB_OPT_PASSWORD = 7014,
    MARIADB_OPT_HOST = 7015,
    MARIADB_OPT_USER = 7016,
    MARIADB_OPT_SCHEMA = 7017,
    MARIADB_OPT_DEBUG = 7018,
    MARIADB_OPT_FOUND_ROWS = 7019,
    MARIADB_OPT_MULTI_RESULTS = 7020,
    MARIADB_OPT_MULTI_STATEMENTS = 7021,
    MARIADB_OPT_INTERACTIVE = 7022,
    MARIADB_OPT_PROXY_HEADER = 7023,
    MARIADB_OPT_IO_WAIT = 7024,
    MARIADB_OPT_SKIP_READ_RESPONSE = 7025,
    MARIADB_OPT_RESTRICTED_AUTH = 7026,
    MARIADB_OPT_RPL_REGISTER_REPLICA = 7027,
    MARIADB_OPT_STATUS_CALLBACK = 7028,
    MARIADB_OPT_SERVER_PLUGINS = 7029,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum mariadb_value {
    MARIADB_CHARSET_ID = 0,
    MARIADB_CHARSET_NAME = 1,
    MARIADB_CLIENT_ERRORS = 2,
    MARIADB_CLIENT_VERSION = 3,
    MARIADB_CLIENT_VERSION_ID = 4,
    MARIADB_CONNECTION_ASYNC_TIMEOUT = 5,
    MARIADB_CONNECTION_ASYNC_TIMEOUT_MS = 6,
    MARIADB_CONNECTION_MARIADB_CHARSET_INFO = 7,
    MARIADB_CONNECTION_ERROR = 8,
    MARIADB_CONNECTION_ERROR_ID = 9,
    MARIADB_CONNECTION_HOST = 10,
    MARIADB_CONNECTION_INFO = 11,
    MARIADB_CONNECTION_PORT = 12,
    MARIADB_CONNECTION_PROTOCOL_VERSION_ID = 13,
    MARIADB_CONNECTION_PVIO_TYPE = 14,
    MARIADB_CONNECTION_SCHEMA = 15,
    MARIADB_CONNECTION_SERVER_TYPE = 16,
    MARIADB_CONNECTION_SERVER_VERSION = 17,
    MARIADB_CONNECTION_SERVER_VERSION_ID = 18,
    MARIADB_CONNECTION_SOCKET = 19,
    MARIADB_CONNECTION_SQLSTATE = 20,
    MARIADB_CONNECTION_SSL_CIPHER = 21,
    MARIADB_TLS_LIBRARY = 22,
    MARIADB_CONNECTION_TLS_VERSION = 23,
    MARIADB_CONNECTION_TLS_VERSION_ID = 24,
    MARIADB_CONNECTION_TYPE = 25,
    MARIADB_CONNECTION_UNIX_SOCKET = 26,
    MARIADB_CONNECTION_USER = 27,
    MARIADB_MAX_ALLOWED_PACKET = 28,
    MARIADB_NET_BUFFER_LENGTH = 29,
    MARIADB_CONNECTION_SERVER_STATUS = 30,
    MARIADB_CONNECTION_SERVER_CAPABILITIES = 31,
    MARIADB_CONNECTION_EXTENDED_SERVER_CAPABILITIES = 32,
    MARIADB_CONNECTION_CLIENT_CAPABILITIES = 33,
    MARIADB_CONNECTION_BYTES_READ = 34,
    MARIADB_CONNECTION_BYTES_SENT = 35,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum mysql_status {
    MYSQL_STATUS_READY = 0,
    MYSQL_STATUS_GET_RESULT = 1,
    MYSQL_STATUS_USE_RESULT = 2,
    MYSQL_STATUS_QUERY_SENT = 3,
    MYSQL_STATUS_SENDING_LOAD_DATA = 4,
    MYSQL_STATUS_FETCHING_DATA = 5,
    MYSQL_STATUS_NEXT_RESULT_PENDING = 6,
    MYSQL_STATUS_QUIT_SENT = 7,
    MYSQL_STATUS_STMT_RESULT = 8,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum mysql_protocol_type {
    MYSQL_PROTOCOL_DEFAULT = 0,
    MYSQL_PROTOCOL_TCP = 1,
    MYSQL_PROTOCOL_SOCKET = 2,
    MYSQL_PROTOCOL_PIPE = 3,
    MYSQL_PROTOCOL_MEMORY = 4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_options {
    pub connect_timeout: ::std::os::raw::c_uint,
    pub read_timeout: ::std::os::raw::c_uint,
    pub write_timeout: ::std::os::raw::c_uint,
    pub port: ::std::os::raw::c_uint,
    pub protocol: ::std::os::raw::c_uint,
    pub client_flag: ::std::os::raw::c_ulong,
    pub host: *mut ::std::os::raw::c_char,
    pub user: *mut ::std::os::raw::c_char,
    pub password: *mut ::std::os::raw::c_char,
    pub unix_socket: *mut ::std::os::raw::c_char,
    pub db: *mut ::std::os::raw::c_char,
    pub init_command: *mut st_dynamic_array,
    pub my_cnf_file: *mut ::std::os::raw::c_char,
    pub my_cnf_group: *mut ::std::os::raw::c_char,
    pub charset_dir: *mut ::std::os::raw::c_char,
    pub charset_name: *mut ::std::os::raw::c_char,
    pub ssl_key: *mut ::std::os::raw::c_char,
    pub ssl_cert: *mut ::std::os::raw::c_char,
    pub ssl_ca: *mut ::std::os::raw::c_char,
    pub ssl_capath: *mut ::std::os::raw::c_char,
    pub ssl_cipher: *mut ::std::os::raw::c_char,
    pub shared_memory_base_name: *mut ::std::os::raw::c_char,
    pub max_allowed_packet: ::std::os::raw::c_ulong,
    pub use_ssl: my_bool,
    pub compress: my_bool,
    pub named_pipe: my_bool,
    pub reconnect: my_bool,
    pub unused_1: my_bool,
    pub unused_2: my_bool,
    pub unused_3: my_bool,
    pub methods_to_use: mysql_option,
    pub bind_address: *mut ::std::os::raw::c_char,
    pub secure_auth: my_bool,
    pub report_data_truncation: my_bool,
    pub local_infile_init: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut *mut ::std::os::raw::c_void,
            arg2: *const ::std::os::raw::c_char,
            arg3: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub local_infile_read: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: *mut ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_uint,
        ) -> ::std::os::raw::c_int,
    >,
    pub local_infile_end:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub local_infile_error: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: *mut ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_uint,
        ) -> ::std::os::raw::c_int,
    >,
    pub local_infile_userdata: *mut ::std::os::raw::c_void,
    pub extension: *mut st_mysql_options_extension,
}
#[test]
fn bindgen_test_layout_st_mysql_options() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_options> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_options>(),
        136usize,
        concat!("Size of: ", stringify!(st_mysql_options))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_options>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_options))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).connect_timeout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(connect_timeout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).read_timeout) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(read_timeout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).write_timeout) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(write_timeout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).protocol) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(protocol)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).client_flag) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(client_flag)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).host) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(host)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).user) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(user)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).password) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(password)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unix_socket) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(unix_socket)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(db)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).init_command) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(init_command)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).my_cnf_file) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(my_cnf_file)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).my_cnf_group) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(my_cnf_group)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).charset_dir) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(charset_dir)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).charset_name) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(charset_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ssl_key) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(ssl_key)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ssl_cert) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(ssl_cert)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ssl_ca) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(ssl_ca)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ssl_capath) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(ssl_capath)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ssl_cipher) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(ssl_cipher)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).shared_memory_base_name) as usize - ptr as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(shared_memory_base_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_allowed_packet) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(max_allowed_packet)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).use_ssl) as usize - ptr as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(use_ssl)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).compress) as usize - ptr as usize },
        93usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(compress)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).named_pipe) as usize - ptr as usize },
        94usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(named_pipe)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reconnect) as usize - ptr as usize },
        95usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(reconnect)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_1) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(unused_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_2) as usize - ptr as usize },
        97usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(unused_2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_3) as usize - ptr as usize },
        98usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(unused_3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).methods_to_use) as usize - ptr as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(methods_to_use)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bind_address) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(bind_address)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).secure_auth) as usize - ptr as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(secure_auth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).report_data_truncation) as usize - ptr as usize },
        109usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(report_data_truncation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).local_infile_init) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(local_infile_init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).local_infile_read) as usize - ptr as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(local_infile_read)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).local_infile_end) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(local_infile_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).local_infile_error) as usize - ptr as usize },
        124usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(local_infile_error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).local_infile_userdata) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(local_infile_userdata)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        132usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_options),
            "::",
            stringify!(extension)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql {
    pub net: NET,
    pub unused_0: *mut ::std::os::raw::c_void,
    pub host: *mut ::std::os::raw::c_char,
    pub user: *mut ::std::os::raw::c_char,
    pub passwd: *mut ::std::os::raw::c_char,
    pub unix_socket: *mut ::std::os::raw::c_char,
    pub server_version: *mut ::std::os::raw::c_char,
    pub host_info: *mut ::std::os::raw::c_char,
    pub info: *mut ::std::os::raw::c_char,
    pub db: *mut ::std::os::raw::c_char,
    pub charset: *const ma_charset_info_st,
    pub fields: *mut MYSQL_FIELD,
    pub field_alloc: MA_MEM_ROOT,
    pub affected_rows: ::std::os::raw::c_ulonglong,
    pub insert_id: ::std::os::raw::c_ulonglong,
    pub extra_info: ::std::os::raw::c_ulonglong,
    pub thread_id: ::std::os::raw::c_ulong,
    pub packet_length: ::std::os::raw::c_ulong,
    pub port: ::std::os::raw::c_uint,
    pub client_flag: ::std::os::raw::c_ulong,
    pub server_capabilities: ::std::os::raw::c_ulong,
    pub protocol_version: ::std::os::raw::c_uint,
    pub field_count: ::std::os::raw::c_uint,
    pub server_status: ::std::os::raw::c_uint,
    pub server_language: ::std::os::raw::c_uint,
    pub warning_count: ::std::os::raw::c_uint,
    pub options: st_mysql_options,
    pub status: mysql_status,
    pub free_me: my_bool,
    pub unused_1: my_bool,
    pub scramble_buff: [::std::os::raw::c_char; 21usize],
    pub unused_2: my_bool,
    pub unused_3: *mut ::std::os::raw::c_void,
    pub unused_4: *mut ::std::os::raw::c_void,
    pub unused_5: *mut ::std::os::raw::c_void,
    pub unused_6: *mut ::std::os::raw::c_void,
    pub stmts: *mut LIST,
    pub methods: *const st_mariadb_methods,
    pub thd: *mut ::std::os::raw::c_void,
    pub unbuffered_fetch_owner: *mut my_bool,
    pub info_buffer: *mut ::std::os::raw::c_char,
    pub extension: *mut st_mariadb_extension,
}
#[test]
fn bindgen_test_layout_st_mysql() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql>(),
        968usize,
        concat!("Size of: ", stringify!(st_mysql))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql>(),
        8usize,
        concat!("Alignment of ", stringify!(st_mysql))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).net) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(net)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_0) as usize - ptr as usize },
        620usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unused_0)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).host) as usize - ptr as usize },
        624usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(host)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).user) as usize - ptr as usize },
        628usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(user)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).passwd) as usize - ptr as usize },
        632usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(passwd)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unix_socket) as usize - ptr as usize },
        636usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unix_socket)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).server_version) as usize - ptr as usize },
        640usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(server_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).host_info) as usize - ptr as usize },
        644usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(host_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize },
        648usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db) as usize - ptr as usize },
        652usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(db)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).charset) as usize - ptr as usize },
        656usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(charset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fields) as usize - ptr as usize },
        660usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).field_alloc) as usize - ptr as usize },
        664usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(field_alloc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).affected_rows) as usize - ptr as usize },
        696usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(affected_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).insert_id) as usize - ptr as usize },
        704usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(insert_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extra_info) as usize - ptr as usize },
        712usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(extra_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).thread_id) as usize - ptr as usize },
        720usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(thread_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).packet_length) as usize - ptr as usize },
        724usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(packet_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
        728usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).client_flag) as usize - ptr as usize },
        732usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(client_flag)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).server_capabilities) as usize - ptr as usize },
        736usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(server_capabilities)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).protocol_version) as usize - ptr as usize },
        740usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(protocol_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).field_count) as usize - ptr as usize },
        744usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(field_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).server_status) as usize - ptr as usize },
        748usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(server_status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).server_language) as usize - ptr as usize },
        752usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(server_language)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).warning_count) as usize - ptr as usize },
        756usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(warning_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
        760usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(options)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        896usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).free_me) as usize - ptr as usize },
        900usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(free_me)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_1) as usize - ptr as usize },
        901usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unused_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scramble_buff) as usize - ptr as usize },
        902usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(scramble_buff)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_2) as usize - ptr as usize },
        923usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unused_2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_3) as usize - ptr as usize },
        924usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unused_3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_4) as usize - ptr as usize },
        928usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unused_4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_5) as usize - ptr as usize },
        932usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unused_5)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unused_6) as usize - ptr as usize },
        936usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unused_6)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stmts) as usize - ptr as usize },
        940usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(stmts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).methods) as usize - ptr as usize },
        944usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(methods)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).thd) as usize - ptr as usize },
        948usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(thd)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unbuffered_fetch_owner) as usize - ptr as usize },
        952usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(unbuffered_fetch_owner)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).info_buffer) as usize - ptr as usize },
        956usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(info_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        960usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql),
            "::",
            stringify!(extension)
        )
    );
}
pub type MYSQL = st_mysql;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_res {
    pub row_count: ::std::os::raw::c_ulonglong,
    pub field_count: ::std::os::raw::c_uint,
    pub current_field: ::std::os::raw::c_uint,
    pub fields: *mut MYSQL_FIELD,
    pub data: *mut MYSQL_DATA,
    pub data_cursor: *mut MYSQL_ROWS,
    pub field_alloc: MA_MEM_ROOT,
    pub row: MYSQL_ROW,
    pub current_row: MYSQL_ROW,
    pub lengths: *mut ::std::os::raw::c_ulong,
    pub handle: *mut MYSQL,
    pub eof: my_bool,
    pub is_ps: my_bool,
}
#[test]
fn bindgen_test_layout_st_mysql_res() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_res> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_res>(),
        80usize,
        concat!("Size of: ", stringify!(st_mysql_res))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_res>(),
        8usize,
        concat!("Alignment of ", stringify!(st_mysql_res))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).row_count) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(row_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).field_count) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(field_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_field) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(current_field)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fields) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data_cursor) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(data_cursor)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).field_alloc) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(field_alloc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).row) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(row)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_row) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(current_row)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lengths) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(lengths)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(handle)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eof) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(eof)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).is_ps) as usize - ptr as usize },
        77usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_res),
            "::",
            stringify!(is_ps)
        )
    );
}
pub type MYSQL_RES = st_mysql_res;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MYSQL_PARAMETERS {
    pub p_max_allowed_packet: *mut ::std::os::raw::c_ulong,
    pub p_net_buffer_length: *mut ::std::os::raw::c_ulong,
    pub extension: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MYSQL_PARAMETERS() {
    const UNINIT: ::std::mem::MaybeUninit<MYSQL_PARAMETERS> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<MYSQL_PARAMETERS>(),
        12usize,
        concat!("Size of: ", stringify!(MYSQL_PARAMETERS))
    );
    assert_eq!(
        ::std::mem::align_of::<MYSQL_PARAMETERS>(),
        4usize,
        concat!("Alignment of ", stringify!(MYSQL_PARAMETERS))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p_max_allowed_packet) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MYSQL_PARAMETERS),
            "::",
            stringify!(p_max_allowed_packet)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p_net_buffer_length) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MYSQL_PARAMETERS),
            "::",
            stringify!(p_net_buffer_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MYSQL_PARAMETERS),
            "::",
            stringify!(extension)
        )
    );
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum mariadb_field_attr_t {
    MARIADB_FIELD_ATTR_DATA_TYPE_NAME = 0,
    MARIADB_FIELD_ATTR_FORMAT_NAME = 1,
}
extern "stdcall" {
    pub fn mariadb_field_attr(
        attr: *mut MARIADB_CONST_STRING,
        field: *const MYSQL_FIELD,
        type_: mariadb_field_attr_t,
    ) -> ::std::os::raw::c_int;
}
#[repr(i32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum enum_mysql_timestamp_type {
    MYSQL_TIMESTAMP_NONE = -2,
    MYSQL_TIMESTAMP_ERROR = -1,
    MYSQL_TIMESTAMP_DATE = 0,
    MYSQL_TIMESTAMP_DATETIME = 1,
    MYSQL_TIMESTAMP_TIME = 2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_time {
    pub year: ::std::os::raw::c_uint,
    pub month: ::std::os::raw::c_uint,
    pub day: ::std::os::raw::c_uint,
    pub hour: ::std::os::raw::c_uint,
    pub minute: ::std::os::raw::c_uint,
    pub second: ::std::os::raw::c_uint,
    pub second_part: ::std::os::raw::c_ulong,
    pub neg: my_bool,
    pub time_type: enum_mysql_timestamp_type,
}
#[test]
fn bindgen_test_layout_st_mysql_time() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_time> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_time>(),
        36usize,
        concat!("Size of: ", stringify!(st_mysql_time))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_time>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_time))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).year) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(year)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).month) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(month)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).day) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(day)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hour) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(hour)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).minute) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(minute)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(second)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).second_part) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(second_part)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).neg) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(neg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_type) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_time),
            "::",
            stringify!(time_type)
        )
    );
}
pub type MYSQL_TIME = st_mysql_time;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct character_set {
    pub number: ::std::os::raw::c_uint,
    pub state: ::std::os::raw::c_uint,
    pub csname: *const ::std::os::raw::c_char,
    pub name: *const ::std::os::raw::c_char,
    pub comment: *const ::std::os::raw::c_char,
    pub dir: *const ::std::os::raw::c_char,
    pub mbminlen: ::std::os::raw::c_uint,
    pub mbmaxlen: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_character_set() {
    const UNINIT: ::std::mem::MaybeUninit<character_set> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<character_set>(),
        32usize,
        concat!("Size of: ", stringify!(character_set))
    );
    assert_eq!(
        ::std::mem::align_of::<character_set>(),
        4usize,
        concat!("Alignment of ", stringify!(character_set))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(number)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).csname) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(csname)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).comment) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(comment)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dir) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(dir)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mbminlen) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(mbminlen)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mbmaxlen) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(character_set),
            "::",
            stringify!(mbmaxlen)
        )
    );
}
pub type MY_CHARSET_INFO = character_set;
pub type MYSQL_STMT = st_mysql_stmt;
pub type mysql_stmt_use_or_store_func =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut MYSQL_STMT) -> *mut MYSQL_RES>;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum enum_stmt_attr_type {
    STMT_ATTR_UPDATE_MAX_LENGTH = 0,
    STMT_ATTR_CURSOR_TYPE = 1,
    STMT_ATTR_PREFETCH_ROWS = 2,
    STMT_ATTR_PREBIND_PARAMS = 200,
    STMT_ATTR_ARRAY_SIZE = 201,
    STMT_ATTR_ROW_SIZE = 202,
    STMT_ATTR_STATE = 203,
    STMT_ATTR_CB_USER_DATA = 204,
    STMT_ATTR_CB_PARAM = 205,
    STMT_ATTR_CB_RESULT = 206,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum mysql_stmt_state {
    MYSQL_STMT_INITTED = 0,
    MYSQL_STMT_PREPARED = 1,
    MYSQL_STMT_EXECUTED = 2,
    MYSQL_STMT_WAITING_USE_OR_STORE = 3,
    MYSQL_STMT_USE_OR_STORE_CALLED = 4,
    MYSQL_STMT_USER_FETCHING = 5,
    MYSQL_STMT_FETCH_DONE = 6,
}
pub use self::mysql_stmt_state as enum_mysqlnd_stmt_state;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct st_mysql_bind {
    pub length: *mut ::std::os::raw::c_ulong,
    pub is_null: *mut my_bool,
    pub buffer: *mut ::std::os::raw::c_void,
    pub error: *mut my_bool,
    pub u: st_mysql_bind__bindgen_ty_1,
    pub store_param_func:
        ::std::option::Option<unsafe extern "C" fn(net: *mut NET, param: *mut st_mysql_bind)>,
    pub fetch_result: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut st_mysql_bind,
            arg2: *mut MYSQL_FIELD,
            row: *mut *mut ::std::os::raw::c_uchar,
        ),
    >,
    pub skip_result: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut st_mysql_bind,
            arg2: *mut MYSQL_FIELD,
            row: *mut *mut ::std::os::raw::c_uchar,
        ),
    >,
    pub buffer_length: ::std::os::raw::c_ulong,
    pub offset: ::std::os::raw::c_ulong,
    pub length_value: ::std::os::raw::c_ulong,
    pub flags: ::std::os::raw::c_uint,
    pub pack_length: ::std::os::raw::c_uint,
    pub buffer_type: enum_field_types,
    pub error_value: my_bool,
    pub is_unsigned: my_bool,
    pub long_data_used: my_bool,
    pub is_null_value: my_bool,
    pub extension: *mut ::std::os::raw::c_void,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union st_mysql_bind__bindgen_ty_1 {
    pub row_ptr: *mut ::std::os::raw::c_uchar,
    pub indicator: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_st_mysql_bind__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_bind__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_bind__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(st_mysql_bind__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_bind__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_bind__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).row_ptr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind__bindgen_ty_1),
            "::",
            stringify!(row_ptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).indicator) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind__bindgen_ty_1),
            "::",
            stringify!(indicator)
        )
    );
}
#[test]
fn bindgen_test_layout_st_mysql_bind() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_bind> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_bind>(),
        64usize,
        concat!("Size of: ", stringify!(st_mysql_bind))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_bind>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_bind))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).is_null) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(is_null)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(u)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).store_param_func) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(store_param_func)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fetch_result) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(fetch_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).skip_result) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(skip_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buffer_length) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(buffer_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length_value) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(length_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pack_length) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(pack_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buffer_type) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(buffer_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error_value) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(error_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).is_unsigned) as usize - ptr as usize },
        57usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(is_unsigned)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).long_data_used) as usize - ptr as usize },
        58usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(long_data_used)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).is_null_value) as usize - ptr as usize },
        59usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(is_null_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_bind),
            "::",
            stringify!(extension)
        )
    );
}
pub type MYSQL_BIND = st_mysql_bind;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysqlnd_upsert_result {
    pub warning_count: ::std::os::raw::c_uint,
    pub server_status: ::std::os::raw::c_uint,
    pub affected_rows: ::std::os::raw::c_ulonglong,
    pub last_insert_id: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_st_mysqlnd_upsert_result() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysqlnd_upsert_result> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysqlnd_upsert_result>(),
        24usize,
        concat!("Size of: ", stringify!(st_mysqlnd_upsert_result))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysqlnd_upsert_result>(),
        8usize,
        concat!("Alignment of ", stringify!(st_mysqlnd_upsert_result))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).warning_count) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysqlnd_upsert_result),
            "::",
            stringify!(warning_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).server_status) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysqlnd_upsert_result),
            "::",
            stringify!(server_status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).affected_rows) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysqlnd_upsert_result),
            "::",
            stringify!(affected_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_insert_id) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysqlnd_upsert_result),
            "::",
            stringify!(last_insert_id)
        )
    );
}
pub type mysql_upsert_status = st_mysqlnd_upsert_result;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_cmd_buffer {
    pub buffer: *mut ::std::os::raw::c_uchar,
    pub length: usize,
}
#[test]
fn bindgen_test_layout_st_mysql_cmd_buffer() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_cmd_buffer> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_cmd_buffer>(),
        8usize,
        concat!("Size of: ", stringify!(st_mysql_cmd_buffer))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_cmd_buffer>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_cmd_buffer))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_cmd_buffer),
            "::",
            stringify!(buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_cmd_buffer),
            "::",
            stringify!(length)
        )
    );
}
pub type MYSQL_CMD_BUFFER = st_mysql_cmd_buffer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_error_info {
    pub error_no: ::std::os::raw::c_uint,
    pub error: [::std::os::raw::c_char; 513usize],
    pub sqlstate: [::std::os::raw::c_char; 6usize],
}
#[test]
fn bindgen_test_layout_st_mysql_error_info() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_error_info> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_error_info>(),
        524usize,
        concat!("Size of: ", stringify!(st_mysql_error_info))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_error_info>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_error_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error_no) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_error_info),
            "::",
            stringify!(error_no)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_error_info),
            "::",
            stringify!(error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sqlstate) as usize - ptr as usize },
        517usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_error_info),
            "::",
            stringify!(sqlstate)
        )
    );
}
pub type mysql_error_info = st_mysql_error_info;
pub type mysql_stmt_fetch_row_func = ::std::option::Option<
    unsafe extern "C" fn(
        stmt: *mut MYSQL_STMT,
        row: *mut *mut ::std::os::raw::c_uchar,
    ) -> ::std::os::raw::c_int,
>;
pub type ps_result_callback = ::std::option::Option<
    unsafe extern "C" fn(
        data: *mut ::std::os::raw::c_void,
        column: ::std::os::raw::c_uint,
        row: *mut *mut ::std::os::raw::c_uchar,
    ),
>;
pub type ps_param_callback = ::std::option::Option<
    unsafe extern "C" fn(
        data: *mut ::std::os::raw::c_void,
        bind: *mut MYSQL_BIND,
        row_nr: ::std::os::raw::c_uint,
    ) -> *mut my_bool,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_stmt {
    pub mem_root: MA_MEM_ROOT,
    pub mysql: *mut MYSQL,
    pub stmt_id: ::std::os::raw::c_ulong,
    pub flags: ::std::os::raw::c_ulong,
    pub state: enum_mysqlnd_stmt_state,
    pub fields: *mut MYSQL_FIELD,
    pub field_count: ::std::os::raw::c_uint,
    pub param_count: ::std::os::raw::c_uint,
    pub send_types_to_server: ::std::os::raw::c_uchar,
    pub params: *mut MYSQL_BIND,
    pub bind: *mut MYSQL_BIND,
    pub result: MYSQL_DATA,
    pub result_cursor: *mut MYSQL_ROWS,
    pub bind_result_done: my_bool,
    pub bind_param_done: my_bool,
    pub upsert_status: mysql_upsert_status,
    pub last_errno: ::std::os::raw::c_uint,
    pub last_error: [::std::os::raw::c_char; 513usize],
    pub sqlstate: [::std::os::raw::c_char; 6usize],
    pub update_max_length: my_bool,
    pub prefetch_rows: ::std::os::raw::c_ulong,
    pub list: LIST,
    pub cursor_exists: my_bool,
    pub extension: *mut ::std::os::raw::c_void,
    pub fetch_row_func: mysql_stmt_fetch_row_func,
    pub execute_count: ::std::os::raw::c_uint,
    pub default_rset_handler: mysql_stmt_use_or_store_func,
    pub request_buffer: *mut ::std::os::raw::c_uchar,
    pub array_size: ::std::os::raw::c_uint,
    pub row_size: usize,
    pub prebind_params: ::std::os::raw::c_uint,
    pub user_data: *mut ::std::os::raw::c_void,
    pub result_callback: ps_result_callback,
    pub param_callback: ps_param_callback,
    pub request_length: usize,
}
#[test]
fn bindgen_test_layout_st_mysql_stmt() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_stmt> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_stmt>(),
        752usize,
        concat!("Size of: ", stringify!(st_mysql_stmt))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_stmt>(),
        8usize,
        concat!("Alignment of ", stringify!(st_mysql_stmt))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mem_root) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(mem_root)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(mysql)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stmt_id) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(stmt_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fields) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).field_count) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(field_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).param_count) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(param_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).send_types_to_server) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(send_types_to_server)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(params)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bind) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(bind)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result_cursor) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(result_cursor)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bind_result_done) as usize - ptr as usize },
        132usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(bind_result_done)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bind_param_done) as usize - ptr as usize },
        133usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(bind_param_done)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).upsert_status) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(upsert_status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_errno) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(last_errno)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_error) as usize - ptr as usize },
        164usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(last_error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sqlstate) as usize - ptr as usize },
        677usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(sqlstate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).update_max_length) as usize - ptr as usize },
        683usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(update_max_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prefetch_rows) as usize - ptr as usize },
        684usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(prefetch_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).list) as usize - ptr as usize },
        688usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(list)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cursor_exists) as usize - ptr as usize },
        700usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(cursor_exists)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        704usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(extension)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fetch_row_func) as usize - ptr as usize },
        708usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(fetch_row_func)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).execute_count) as usize - ptr as usize },
        712usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(execute_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).default_rset_handler) as usize - ptr as usize },
        716usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(default_rset_handler)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).request_buffer) as usize - ptr as usize },
        720usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(request_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).array_size) as usize - ptr as usize },
        724usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(array_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).row_size) as usize - ptr as usize },
        728usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(row_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prebind_params) as usize - ptr as usize },
        732usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(prebind_params)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
        736usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(user_data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result_callback) as usize - ptr as usize },
        740usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(result_callback)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).param_callback) as usize - ptr as usize },
        744usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(param_callback)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).request_length) as usize - ptr as usize },
        748usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_stmt),
            "::",
            stringify!(request_length)
        )
    );
}
pub type ps_field_fetch_func = ::std::option::Option<
    unsafe extern "C" fn(
        r_param: *mut MYSQL_BIND,
        field: *const MYSQL_FIELD,
        row: *mut *mut ::std::os::raw::c_uchar,
    ),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_perm_bind {
    pub func: ps_field_fetch_func,
    pub pack_len: ::std::os::raw::c_int,
    pub max_len: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_st_mysql_perm_bind() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_perm_bind> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_perm_bind>(),
        12usize,
        concat!("Size of: ", stringify!(st_mysql_perm_bind))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_perm_bind>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_perm_bind))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_perm_bind),
            "::",
            stringify!(func)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pack_len) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_perm_bind),
            "::",
            stringify!(pack_len)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_len) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_perm_bind),
            "::",
            stringify!(max_len)
        )
    );
}
pub type MYSQL_PS_CONVERSION = st_mysql_perm_bind;
extern "C" {
    pub fn mysql_init_ps_subsystem();
}
extern "stdcall" {
    pub fn mysql_stmt_init(mysql: *mut MYSQL) -> *mut MYSQL_STMT;
}
extern "stdcall" {
    pub fn mysql_stmt_prepare(
        stmt: *mut MYSQL_STMT,
        query: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_execute(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_fetch(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_fetch_column(
        stmt: *mut MYSQL_STMT,
        bind_arg: *mut MYSQL_BIND,
        column: ::std::os::raw::c_uint,
        offset: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_store_result(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_param_count(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_stmt_attr_set(
        stmt: *mut MYSQL_STMT,
        attr_type: enum_stmt_attr_type,
        attr: *const ::std::os::raw::c_void,
    ) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_attr_get(
        stmt: *mut MYSQL_STMT,
        attr_type: enum_stmt_attr_type,
        attr: *mut ::std::os::raw::c_void,
    ) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_bind_param(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_bind_result(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_close(stmt: *mut MYSQL_STMT) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_reset(stmt: *mut MYSQL_STMT) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_free_result(stmt: *mut MYSQL_STMT) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_send_long_data(
        stmt: *mut MYSQL_STMT,
        param_number: ::std::os::raw::c_uint,
        data: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_stmt_result_metadata(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_stmt_param_metadata(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_stmt_errno(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_stmt_error(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_stmt_sqlstate(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_stmt_row_seek(stmt: *mut MYSQL_STMT, offset: MYSQL_ROW_OFFSET)
        -> MYSQL_ROW_OFFSET;
}
extern "stdcall" {
    pub fn mysql_stmt_row_tell(stmt: *mut MYSQL_STMT) -> MYSQL_ROW_OFFSET;
}
extern "stdcall" {
    pub fn mysql_stmt_data_seek(stmt: *mut MYSQL_STMT, offset: ::std::os::raw::c_ulonglong);
}
extern "stdcall" {
    pub fn mysql_stmt_num_rows(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong;
}
extern "stdcall" {
    pub fn mysql_stmt_affected_rows(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong;
}
extern "stdcall" {
    pub fn mysql_stmt_insert_id(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong;
}
extern "stdcall" {
    pub fn mysql_stmt_field_count(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_stmt_next_result(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_more_results(stmt: *mut MYSQL_STMT) -> my_bool;
}
extern "stdcall" {
    pub fn mariadb_stmt_execute_direct(
        stmt: *mut MYSQL_STMT,
        stmt_str: *const ::std::os::raw::c_char,
        length: usize,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mariadb_stmt_fetch_fields(stmt: *mut MYSQL_STMT) -> *mut MYSQL_FIELD;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_client_plugin {
    pub type_: ::std::os::raw::c_int,
    pub interface_version: ::std::os::raw::c_uint,
    pub name: *const ::std::os::raw::c_char,
    pub author: *const ::std::os::raw::c_char,
    pub desc: *const ::std::os::raw::c_char,
    pub version: [::std::os::raw::c_uint; 3usize],
    pub license: *const ::std::os::raw::c_char,
    pub mysql_api: *mut ::std::os::raw::c_void,
    pub init: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_char,
            arg2: usize,
            arg3: ::std::os::raw::c_int,
            arg4: va_list,
        ) -> ::std::os::raw::c_int,
    >,
    pub deinit: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
    pub options: ::std::option::Option<
        unsafe extern "C" fn(
            option: *const ::std::os::raw::c_char,
            arg1: *const ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_st_mysql_client_plugin() {
    const UNINIT: ::std::mem::MaybeUninit<st_mysql_client_plugin> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mysql_client_plugin>(),
        52usize,
        concat!("Size of: ", stringify!(st_mysql_client_plugin))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mysql_client_plugin>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mysql_client_plugin))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).interface_version) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(interface_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).author) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(author)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(desc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).license) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(license)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_api) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(mysql_api)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).init) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).deinit) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(deinit)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mysql_client_plugin),
            "::",
            stringify!(options)
        )
    );
}
extern "C" {
    pub fn mysql_load_plugin(
        mysql: *mut st_mysql,
        name: *const ::std::os::raw::c_char,
        type_: ::std::os::raw::c_int,
        argc: ::std::os::raw::c_int,
        ...
    ) -> *mut st_mysql_client_plugin;
}
extern "stdcall" {
    pub fn mysql_load_plugin_v(
        mysql: *mut st_mysql,
        name: *const ::std::os::raw::c_char,
        type_: ::std::os::raw::c_int,
        argc: ::std::os::raw::c_int,
        args: va_list,
    ) -> *mut st_mysql_client_plugin;
}
extern "stdcall" {
    pub fn mysql_client_find_plugin(
        mysql: *mut st_mysql,
        name: *const ::std::os::raw::c_char,
        type_: ::std::os::raw::c_int,
    ) -> *mut st_mysql_client_plugin;
}
extern "stdcall" {
    pub fn mysql_client_register_plugin(
        mysql: *mut st_mysql,
        plugin: *mut st_mysql_client_plugin,
    ) -> *mut st_mysql_client_plugin;
}
extern "stdcall" {
    pub fn mysql_set_local_infile_handler(
        mysql: *mut MYSQL,
        local_infile_init: ::std::option::Option<
            unsafe extern "C" fn(
                arg1: *mut *mut ::std::os::raw::c_void,
                arg2: *const ::std::os::raw::c_char,
                arg3: *mut ::std::os::raw::c_void,
            ) -> ::std::os::raw::c_int,
        >,
        local_infile_read: ::std::option::Option<
            unsafe extern "C" fn(
                arg1: *mut ::std::os::raw::c_void,
                arg2: *mut ::std::os::raw::c_char,
                arg3: ::std::os::raw::c_uint,
            ) -> ::std::os::raw::c_int,
        >,
        local_infile_end: ::std::option::Option<
            unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void),
        >,
        local_infile_error: ::std::option::Option<
            unsafe extern "C" fn(
                arg1: *mut ::std::os::raw::c_void,
                arg2: *mut ::std::os::raw::c_char,
                arg3: ::std::os::raw::c_uint,
            ) -> ::std::os::raw::c_int,
        >,
        arg1: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn mysql_set_local_infile_default(mysql: *mut MYSQL);
}
extern "stdcall" {
    pub fn mysql_num_rows(res: *mut MYSQL_RES) -> my_ulonglong;
}
extern "stdcall" {
    pub fn mysql_num_fields(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_eof(res: *mut MYSQL_RES) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_fetch_field_direct(
        res: *mut MYSQL_RES,
        fieldnr: ::std::os::raw::c_uint,
    ) -> *mut MYSQL_FIELD;
}
extern "stdcall" {
    pub fn mysql_fetch_fields(res: *mut MYSQL_RES) -> *mut MYSQL_FIELD;
}
extern "stdcall" {
    pub fn mysql_row_tell(res: *mut MYSQL_RES) -> *mut MYSQL_ROWS;
}
extern "stdcall" {
    pub fn mysql_field_tell(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_field_count(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_more_results(mysql: *mut MYSQL) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_next_result(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_affected_rows(mysql: *mut MYSQL) -> my_ulonglong;
}
extern "stdcall" {
    pub fn mysql_autocommit(mysql: *mut MYSQL, mode: my_bool) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_commit(mysql: *mut MYSQL) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_rollback(mysql: *mut MYSQL) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_insert_id(mysql: *mut MYSQL) -> my_ulonglong;
}
extern "stdcall" {
    pub fn mysql_errno(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_error(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_info(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_thread_id(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_character_set_name(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_get_character_set_info(mysql: *mut MYSQL, cs: *mut MY_CHARSET_INFO);
}
extern "stdcall" {
    pub fn mysql_set_character_set(
        mysql: *mut MYSQL,
        csname: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mariadb_get_infov(
        mysql: *mut MYSQL,
        value: mariadb_value,
        arg: *mut ::std::os::raw::c_void,
        ...
    ) -> my_bool;
}
extern "stdcall" {
    pub fn mariadb_get_info(
        mysql: *mut MYSQL,
        value: mariadb_value,
        arg: *mut ::std::os::raw::c_void,
    ) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_init(mysql: *mut MYSQL) -> *mut MYSQL;
}
extern "stdcall" {
    pub fn mysql_ssl_set(
        mysql: *mut MYSQL,
        key: *const ::std::os::raw::c_char,
        cert: *const ::std::os::raw::c_char,
        ca: *const ::std::os::raw::c_char,
        capath: *const ::std::os::raw::c_char,
        cipher: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_get_ssl_cipher(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_change_user(
        mysql: *mut MYSQL,
        user: *const ::std::os::raw::c_char,
        passwd: *const ::std::os::raw::c_char,
        db: *const ::std::os::raw::c_char,
    ) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_real_connect(
        mysql: *mut MYSQL,
        host: *const ::std::os::raw::c_char,
        user: *const ::std::os::raw::c_char,
        passwd: *const ::std::os::raw::c_char,
        db: *const ::std::os::raw::c_char,
        port: ::std::os::raw::c_uint,
        unix_socket: *const ::std::os::raw::c_char,
        clientflag: ::std::os::raw::c_ulong,
    ) -> *mut MYSQL;
}
extern "stdcall" {
    pub fn mysql_close(sock: *mut MYSQL);
}
extern "stdcall" {
    pub fn mysql_select_db(
        mysql: *mut MYSQL,
        db: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_query(
        mysql: *mut MYSQL,
        q: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_send_query(
        mysql: *mut MYSQL,
        q: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_read_query_result(mysql: *mut MYSQL) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_real_query(
        mysql: *mut MYSQL,
        q: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_shutdown(
        mysql: *mut MYSQL,
        shutdown_level: mysql_enum_shutdown_level,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_dump_debug_info(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_refresh(
        mysql: *mut MYSQL,
        refresh_options: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_kill(mysql: *mut MYSQL, pid: ::std::os::raw::c_ulong) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_ping(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stat(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_get_server_info(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_get_server_version(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_get_host_info(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_get_proto_info(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_list_dbs(mysql: *mut MYSQL, wild: *const ::std::os::raw::c_char)
        -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_list_tables(
        mysql: *mut MYSQL,
        wild: *const ::std::os::raw::c_char,
    ) -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_list_fields(
        mysql: *mut MYSQL,
        table: *const ::std::os::raw::c_char,
        wild: *const ::std::os::raw::c_char,
    ) -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_list_processes(mysql: *mut MYSQL) -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_store_result(mysql: *mut MYSQL) -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_use_result(mysql: *mut MYSQL) -> *mut MYSQL_RES;
}
extern "stdcall" {
    pub fn mysql_options(
        mysql: *mut MYSQL,
        option: mysql_option,
        arg: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_options4(
        mysql: *mut MYSQL,
        option: mysql_option,
        arg1: *const ::std::os::raw::c_void,
        arg2: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_free_result(result: *mut MYSQL_RES);
}
extern "stdcall" {
    pub fn mysql_data_seek(result: *mut MYSQL_RES, offset: ::std::os::raw::c_ulonglong);
}
extern "stdcall" {
    pub fn mysql_row_seek(result: *mut MYSQL_RES, arg1: MYSQL_ROW_OFFSET) -> MYSQL_ROW_OFFSET;
}
extern "stdcall" {
    pub fn mysql_field_seek(
        result: *mut MYSQL_RES,
        offset: MYSQL_FIELD_OFFSET,
    ) -> MYSQL_FIELD_OFFSET;
}
extern "stdcall" {
    pub fn mysql_fetch_row(result: *mut MYSQL_RES) -> MYSQL_ROW;
}
extern "stdcall" {
    pub fn mysql_fetch_lengths(result: *mut MYSQL_RES) -> *mut ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_fetch_field(result: *mut MYSQL_RES) -> *mut MYSQL_FIELD;
}
extern "stdcall" {
    pub fn mysql_escape_string(
        to: *mut ::std::os::raw::c_char,
        from: *const ::std::os::raw::c_char,
        from_length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_real_escape_string(
        mysql: *mut MYSQL,
        to: *mut ::std::os::raw::c_char,
        from: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_thread_safe() -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_warning_count(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_sqlstate(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_server_init(
        argc: ::std::os::raw::c_int,
        argv: *mut *mut ::std::os::raw::c_char,
        groups: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_server_end();
}
extern "stdcall" {
    pub fn mysql_thread_end();
}
extern "stdcall" {
    pub fn mysql_thread_init() -> my_bool;
}
extern "stdcall" {
    pub fn mysql_set_server_option(
        mysql: *mut MYSQL,
        option: enum_mysql_set_option,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_get_client_info() -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mysql_get_client_version() -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mariadb_connection(mysql: *mut MYSQL) -> my_bool;
}
extern "stdcall" {
    pub fn mysql_get_server_name(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "stdcall" {
    pub fn mariadb_get_charset_by_name(
        csname: *const ::std::os::raw::c_char,
    ) -> *mut MARIADB_CHARSET_INFO;
}
extern "stdcall" {
    pub fn mariadb_get_charset_by_nr(csnr: ::std::os::raw::c_uint) -> *mut MARIADB_CHARSET_INFO;
}
extern "stdcall" {
    pub fn mariadb_convert_string(
        from: *const ::std::os::raw::c_char,
        from_len: *mut usize,
        from_cs: *mut MARIADB_CHARSET_INFO,
        to: *mut ::std::os::raw::c_char,
        to_len: *mut usize,
        to_cs: *mut MARIADB_CHARSET_INFO,
        errorcode: *mut ::std::os::raw::c_int,
    ) -> usize;
}
extern "C" {
    pub fn mysql_optionsv(mysql: *mut MYSQL, option: mysql_option, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mysql_get_optionv(
        mysql: *mut MYSQL,
        option: mysql_option,
        arg: *mut ::std::os::raw::c_void,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_get_option(
        mysql: *mut MYSQL,
        option: mysql_option,
        arg: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_hex_string(
        to: *mut ::std::os::raw::c_char,
        from: *const ::std::os::raw::c_char,
        len: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_get_socket(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_get_timeout_value(mysql: *const MYSQL) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mysql_get_timeout_value_ms(mysql: *const MYSQL) -> ::std::os::raw::c_uint;
}
extern "stdcall" {
    pub fn mariadb_reconnect(mysql: *mut MYSQL) -> my_bool;
}
extern "stdcall" {
    pub fn mariadb_cancel(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_debug(debug: *const ::std::os::raw::c_char);
}
extern "stdcall" {
    pub fn mysql_net_read_packet(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_net_field_length(
        packet: *mut *mut ::std::os::raw::c_uchar,
    ) -> ::std::os::raw::c_ulong;
}
extern "stdcall" {
    pub fn mysql_embedded() -> my_bool;
}
extern "stdcall" {
    pub fn mysql_get_parameters() -> *mut MYSQL_PARAMETERS;
}
extern "stdcall" {
    pub fn mysql_close_start(sock: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_close_cont(
        sock: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_commit_start(ret: *mut my_bool, mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_commit_cont(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_dump_debug_info_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        ready_status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_dump_debug_info_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_rollback_start(ret: *mut my_bool, mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_rollback_cont(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_autocommit_start(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
        auto_mode: my_bool,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_list_fields_cont(
        ret: *mut *mut MYSQL_RES,
        mysql: *mut MYSQL,
        ready_status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_list_fields_start(
        ret: *mut *mut MYSQL_RES,
        mysql: *mut MYSQL,
        table: *const ::std::os::raw::c_char,
        wild: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_autocommit_cont(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_next_result_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_next_result_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_select_db_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        db: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_select_db_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        ready_status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_warning_count(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_next_result_start(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_next_result_cont(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_set_character_set_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        csname: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_set_character_set_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_change_user_start(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
        user: *const ::std::os::raw::c_char,
        passwd: *const ::std::os::raw::c_char,
        db: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_change_user_cont(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_real_connect_start(
        ret: *mut *mut MYSQL,
        mysql: *mut MYSQL,
        host: *const ::std::os::raw::c_char,
        user: *const ::std::os::raw::c_char,
        passwd: *const ::std::os::raw::c_char,
        db: *const ::std::os::raw::c_char,
        port: ::std::os::raw::c_uint,
        unix_socket: *const ::std::os::raw::c_char,
        clientflag: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_real_connect_cont(
        ret: *mut *mut MYSQL,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_query_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        q: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_query_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_send_query_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        q: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_send_query_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_real_query_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        q: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_real_query_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_store_result_start(
        ret: *mut *mut MYSQL_RES,
        mysql: *mut MYSQL,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_store_result_cont(
        ret: *mut *mut MYSQL_RES,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_shutdown_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        shutdown_level: mysql_enum_shutdown_level,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_shutdown_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_refresh_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        refresh_options: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_refresh_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_kill_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        pid: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_kill_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_set_server_option_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        option: enum_mysql_set_option,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_set_server_option_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_ping_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_ping_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stat_start(
        ret: *mut *const ::std::os::raw::c_char,
        mysql: *mut MYSQL,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stat_cont(
        ret: *mut *const ::std::os::raw::c_char,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_free_result_start(result: *mut MYSQL_RES) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_free_result_cont(
        result: *mut MYSQL_RES,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_fetch_row_start(
        ret: *mut MYSQL_ROW,
        result: *mut MYSQL_RES,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_fetch_row_cont(
        ret: *mut MYSQL_ROW,
        result: *mut MYSQL_RES,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_read_query_result_start(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_read_query_result_cont(
        ret: *mut my_bool,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_reset_connection_start(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_reset_connection_cont(
        ret: *mut ::std::os::raw::c_int,
        mysql: *mut MYSQL,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_session_track_get_next(
        mysql: *mut MYSQL,
        type_: enum_session_state_type,
        data: *mut *const ::std::os::raw::c_char,
        length: *mut usize,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_session_track_get_first(
        mysql: *mut MYSQL,
        type_: enum_session_state_type,
        data: *mut *const ::std::os::raw::c_char,
        length: *mut usize,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_prepare_start(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
        query: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_prepare_cont(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_execute_start(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_execute_cont(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_fetch_start(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_fetch_cont(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_store_result_start(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_store_result_cont(
        ret: *mut ::std::os::raw::c_int,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_close_start(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_close_cont(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_reset_start(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_reset_cont(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_free_result_start(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_free_result_cont(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_send_long_data_start(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
        param_number: ::std::os::raw::c_uint,
        data: *const ::std::os::raw::c_char,
        len: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_stmt_send_long_data_cont(
        ret: *mut my_bool,
        stmt: *mut MYSQL_STMT,
        status: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "stdcall" {
    pub fn mysql_reset_connection(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct st_mariadb_api {
    pub mysql_num_rows: ::std::option::Option<
        unsafe extern "stdcall" fn(res: *mut MYSQL_RES) -> ::std::os::raw::c_ulonglong,
    >,
    pub mysql_num_fields: ::std::option::Option<
        unsafe extern "stdcall" fn(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint,
    >,
    pub mysql_eof:
        ::std::option::Option<unsafe extern "stdcall" fn(res: *mut MYSQL_RES) -> my_bool>,
    pub mysql_fetch_field_direct: ::std::option::Option<
        unsafe extern "stdcall" fn(
            res: *mut MYSQL_RES,
            fieldnr: ::std::os::raw::c_uint,
        ) -> *mut MYSQL_FIELD,
    >,
    pub mysql_fetch_fields:
        ::std::option::Option<unsafe extern "stdcall" fn(res: *mut MYSQL_RES) -> *mut MYSQL_FIELD>,
    pub mysql_row_tell:
        ::std::option::Option<unsafe extern "stdcall" fn(res: *mut MYSQL_RES) -> *mut MYSQL_ROWS>,
    pub mysql_field_tell: ::std::option::Option<
        unsafe extern "stdcall" fn(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint,
    >,
    pub mysql_field_count: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint,
    >,
    pub mysql_more_results:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> my_bool>,
    pub mysql_next_result: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int,
    >,
    pub mysql_affected_rows: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulonglong,
    >,
    pub mysql_autocommit: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL, mode: my_bool) -> my_bool,
    >,
    pub mysql_commit:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> my_bool>,
    pub mysql_rollback:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> my_bool>,
    pub mysql_insert_id: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulonglong,
    >,
    pub mysql_errno: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint,
    >,
    pub mysql_error: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
    >,
    pub mysql_info: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
    >,
    pub mysql_thread_id: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong,
    >,
    pub mysql_character_set_name: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
    >,
    pub mysql_get_character_set_info: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL, cs: *mut MY_CHARSET_INFO),
    >,
    pub mysql_set_character_set: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            csname: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub mariadb_get_infov: ::std::option::Option<
        unsafe extern "C" fn(
            mysql: *mut MYSQL,
            value: mariadb_value,
            arg: *mut ::std::os::raw::c_void,
            ...
        ) -> my_bool,
    >,
    pub mariadb_get_info: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            value: mariadb_value,
            arg: *mut ::std::os::raw::c_void,
        ) -> my_bool,
    >,
    pub mysql_init:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut MYSQL>,
    pub mysql_ssl_set: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            key: *const ::std::os::raw::c_char,
            cert: *const ::std::os::raw::c_char,
            ca: *const ::std::os::raw::c_char,
            capath: *const ::std::os::raw::c_char,
            cipher: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_get_ssl_cipher: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
    >,
    pub mysql_change_user: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            user: *const ::std::os::raw::c_char,
            passwd: *const ::std::os::raw::c_char,
            db: *const ::std::os::raw::c_char,
        ) -> my_bool,
    >,
    pub mysql_real_connect: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            host: *const ::std::os::raw::c_char,
            user: *const ::std::os::raw::c_char,
            passwd: *const ::std::os::raw::c_char,
            db: *const ::std::os::raw::c_char,
            port: ::std::os::raw::c_uint,
            unix_socket: *const ::std::os::raw::c_char,
            clientflag: ::std::os::raw::c_ulong,
        ) -> *mut MYSQL,
    >,
    pub mysql_close: ::std::option::Option<unsafe extern "stdcall" fn(sock: *mut MYSQL)>,
    pub mysql_select_db: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            db: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_query: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            q: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_send_query: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            q: *const ::std::os::raw::c_char,
            length: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_read_query_result:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> my_bool>,
    pub mysql_real_query: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            q: *const ::std::os::raw::c_char,
            length: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_shutdown: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            shutdown_level: mysql_enum_shutdown_level,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_dump_debug_info: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int,
    >,
    pub mysql_refresh: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            refresh_options: ::std::os::raw::c_uint,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_kill: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            pid: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_ping: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int,
    >,
    pub mysql_stat: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char,
    >,
    pub mysql_get_server_info: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char,
    >,
    pub mysql_get_server_version: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong,
    >,
    pub mysql_get_host_info: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char,
    >,
    pub mysql_get_proto_info: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint,
    >,
    pub mysql_list_dbs: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            wild: *const ::std::os::raw::c_char,
        ) -> *mut MYSQL_RES,
    >,
    pub mysql_list_tables: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            wild: *const ::std::os::raw::c_char,
        ) -> *mut MYSQL_RES,
    >,
    pub mysql_list_fields: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            table: *const ::std::os::raw::c_char,
            wild: *const ::std::os::raw::c_char,
        ) -> *mut MYSQL_RES,
    >,
    pub mysql_list_processes:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut MYSQL_RES>,
    pub mysql_store_result:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut MYSQL_RES>,
    pub mysql_use_result:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut MYSQL_RES>,
    pub mysql_options: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            option: mysql_option,
            arg: *const ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_free_result:
        ::std::option::Option<unsafe extern "stdcall" fn(result: *mut MYSQL_RES)>,
    pub mysql_data_seek: ::std::option::Option<
        unsafe extern "stdcall" fn(result: *mut MYSQL_RES, offset: ::std::os::raw::c_ulonglong),
    >,
    pub mysql_row_seek: ::std::option::Option<
        unsafe extern "stdcall" fn(
            result: *mut MYSQL_RES,
            arg1: MYSQL_ROW_OFFSET,
        ) -> MYSQL_ROW_OFFSET,
    >,
    pub mysql_field_seek: ::std::option::Option<
        unsafe extern "stdcall" fn(
            result: *mut MYSQL_RES,
            offset: MYSQL_FIELD_OFFSET,
        ) -> MYSQL_FIELD_OFFSET,
    >,
    pub mysql_fetch_row:
        ::std::option::Option<unsafe extern "stdcall" fn(result: *mut MYSQL_RES) -> MYSQL_ROW>,
    pub mysql_fetch_lengths: ::std::option::Option<
        unsafe extern "stdcall" fn(result: *mut MYSQL_RES) -> *mut ::std::os::raw::c_ulong,
    >,
    pub mysql_fetch_field: ::std::option::Option<
        unsafe extern "stdcall" fn(result: *mut MYSQL_RES) -> *mut MYSQL_FIELD,
    >,
    pub mysql_escape_string: ::std::option::Option<
        unsafe extern "stdcall" fn(
            to: *mut ::std::os::raw::c_char,
            from: *const ::std::os::raw::c_char,
            from_length: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_ulong,
    >,
    pub mysql_real_escape_string: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            to: *mut ::std::os::raw::c_char,
            from: *const ::std::os::raw::c_char,
            length: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_ulong,
    >,
    pub mysql_thread_safe:
        ::std::option::Option<unsafe extern "stdcall" fn() -> ::std::os::raw::c_uint>,
    pub mysql_warning_count: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint,
    >,
    pub mysql_sqlstate: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
    >,
    pub mysql_server_init: ::std::option::Option<
        unsafe extern "stdcall" fn(
            argc: ::std::os::raw::c_int,
            argv: *mut *mut ::std::os::raw::c_char,
            groups: *mut *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_server_end: ::std::option::Option<unsafe extern "stdcall" fn()>,
    pub mysql_thread_end: ::std::option::Option<unsafe extern "stdcall" fn()>,
    pub mysql_thread_init: ::std::option::Option<unsafe extern "stdcall" fn() -> my_bool>,
    pub mysql_set_server_option: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            option: enum_mysql_set_option,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_get_client_info:
        ::std::option::Option<unsafe extern "stdcall" fn() -> *const ::std::os::raw::c_char>,
    pub mysql_get_client_version:
        ::std::option::Option<unsafe extern "stdcall" fn() -> ::std::os::raw::c_ulong>,
    pub mariadb_connection:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> my_bool>,
    pub mysql_get_server_name: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
    >,
    pub mariadb_get_charset_by_name: ::std::option::Option<
        unsafe extern "stdcall" fn(
            csname: *const ::std::os::raw::c_char,
        ) -> *mut MARIADB_CHARSET_INFO,
    >,
    pub mariadb_get_charset_by_nr: ::std::option::Option<
        unsafe extern "stdcall" fn(csnr: ::std::os::raw::c_uint) -> *mut MARIADB_CHARSET_INFO,
    >,
    pub mariadb_convert_string: ::std::option::Option<
        unsafe extern "stdcall" fn(
            from: *const ::std::os::raw::c_char,
            from_len: *mut usize,
            from_cs: *mut MARIADB_CHARSET_INFO,
            to: *mut ::std::os::raw::c_char,
            to_len: *mut usize,
            to_cs: *mut MARIADB_CHARSET_INFO,
            errorcode: *mut ::std::os::raw::c_int,
        ) -> usize,
    >,
    pub mysql_optionsv: ::std::option::Option<
        unsafe extern "C" fn(mysql: *mut MYSQL, option: mysql_option, ...) -> ::std::os::raw::c_int,
    >,
    pub mysql_get_optionv: ::std::option::Option<
        unsafe extern "C" fn(
            mysql: *mut MYSQL,
            option: mysql_option,
            arg: *mut ::std::os::raw::c_void,
            ...
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_get_option: ::std::option::Option<
        unsafe extern "stdcall" fn(
            mysql: *mut MYSQL,
            option: mysql_option,
            arg: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_hex_string: ::std::option::Option<
        unsafe extern "stdcall" fn(
            to: *mut ::std::os::raw::c_char,
            from: *const ::std::os::raw::c_char,
            len: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_ulong,
    >,
    pub mysql_get_socket: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint,
    >,
    pub mysql_get_timeout_value: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *const MYSQL) -> ::std::os::raw::c_uint,
    >,
    pub mysql_get_timeout_value_ms: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *const MYSQL) -> ::std::os::raw::c_uint,
    >,
    pub mariadb_reconnect:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> my_bool>,
    pub mysql_stmt_init:
        ::std::option::Option<unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> *mut MYSQL_STMT>,
    pub mysql_stmt_prepare: ::std::option::Option<
        unsafe extern "stdcall" fn(
            stmt: *mut MYSQL_STMT,
            query: *const ::std::os::raw::c_char,
            length: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_stmt_execute: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int,
    >,
    pub mysql_stmt_fetch: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int,
    >,
    pub mysql_stmt_fetch_column: ::std::option::Option<
        unsafe extern "stdcall" fn(
            stmt: *mut MYSQL_STMT,
            bind_arg: *mut MYSQL_BIND,
            column: ::std::os::raw::c_uint,
            offset: ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_stmt_store_result: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int,
    >,
    pub mysql_stmt_param_count: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulong,
    >,
    pub mysql_stmt_attr_set: ::std::option::Option<
        unsafe extern "stdcall" fn(
            stmt: *mut MYSQL_STMT,
            attr_type: enum_stmt_attr_type,
            attr: *const ::std::os::raw::c_void,
        ) -> my_bool,
    >,
    pub mysql_stmt_attr_get: ::std::option::Option<
        unsafe extern "stdcall" fn(
            stmt: *mut MYSQL_STMT,
            attr_type: enum_stmt_attr_type,
            attr: *mut ::std::os::raw::c_void,
        ) -> my_bool,
    >,
    pub mysql_stmt_bind_param: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool,
    >,
    pub mysql_stmt_bind_result: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool,
    >,
    pub mysql_stmt_close:
        ::std::option::Option<unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
    pub mysql_stmt_reset:
        ::std::option::Option<unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
    pub mysql_stmt_free_result:
        ::std::option::Option<unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
    pub mysql_stmt_send_long_data: ::std::option::Option<
        unsafe extern "stdcall" fn(
            stmt: *mut MYSQL_STMT,
            param_number: ::std::os::raw::c_uint,
            data: *const ::std::os::raw::c_char,
            length: ::std::os::raw::c_ulong,
        ) -> my_bool,
    >,
    pub mysql_stmt_result_metadata:
        ::std::option::Option<unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES>,
    pub mysql_stmt_param_metadata:
        ::std::option::Option<unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES>,
    pub mysql_stmt_errno: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint,
    >,
    pub mysql_stmt_error: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char,
    >,
    pub mysql_stmt_sqlstate: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char,
    >,
    pub mysql_stmt_row_seek: ::std::option::Option<
        unsafe extern "stdcall" fn(
            stmt: *mut MYSQL_STMT,
            offset: MYSQL_ROW_OFFSET,
        ) -> MYSQL_ROW_OFFSET,
    >,
    pub mysql_stmt_row_tell: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> MYSQL_ROW_OFFSET,
    >,
    pub mysql_stmt_data_seek: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT, offset: ::std::os::raw::c_ulonglong),
    >,
    pub mysql_stmt_num_rows: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong,
    >,
    pub mysql_stmt_affected_rows: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong,
    >,
    pub mysql_stmt_insert_id: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong,
    >,
    pub mysql_stmt_field_count: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint,
    >,
    pub mysql_stmt_next_result: ::std::option::Option<
        unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int,
    >,
    pub mysql_stmt_more_results:
        ::std::option::Option<unsafe extern "stdcall" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
    pub mariadb_stmt_execute_direct: ::std::option::Option<
        unsafe extern "stdcall" fn(
            stmt: *mut MYSQL_STMT,
            stmtstr: *const ::std::os::raw::c_char,
            length: usize,
        ) -> ::std::os::raw::c_int,
    >,
    pub mysql_reset_connection: ::std::option::Option<
        unsafe extern "stdcall" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_st_mariadb_api() {
    const UNINIT: ::std::mem::MaybeUninit<st_mariadb_api> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mariadb_api>(),
        460usize,
        concat!("Size of: ", stringify!(st_mariadb_api))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mariadb_api>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mariadb_api))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_num_rows) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_num_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_num_fields) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_num_fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_eof) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_eof)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_fetch_field_direct) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_fetch_field_direct)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_fetch_fields) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_fetch_fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_row_tell) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_row_tell)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_field_tell) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_field_tell)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_field_count) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_field_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_more_results) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_more_results)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_next_result) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_next_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_affected_rows) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_affected_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_autocommit) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_autocommit)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_commit) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_commit)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_rollback) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_rollback)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_insert_id) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_insert_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_errno) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_errno)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_error) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_info) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_thread_id) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_thread_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_character_set_name) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_character_set_name)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).mysql_get_character_set_info) as usize - ptr as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_character_set_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_set_character_set) as usize - ptr as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_set_character_set)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_get_infov) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_get_infov)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_get_info) as usize - ptr as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_get_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_init) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_ssl_set) as usize - ptr as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_ssl_set)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_ssl_cipher) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_ssl_cipher)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_change_user) as usize - ptr as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_change_user)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_real_connect) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_real_connect)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_close) as usize - ptr as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_close)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_select_db) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_select_db)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_query) as usize - ptr as usize },
        124usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_query)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_send_query) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_send_query)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_read_query_result) as usize - ptr as usize },
        132usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_read_query_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_real_query) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_real_query)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_shutdown) as usize - ptr as usize },
        140usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_shutdown)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_dump_debug_info) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_dump_debug_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_refresh) as usize - ptr as usize },
        148usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_refresh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_kill) as usize - ptr as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_kill)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_ping) as usize - ptr as usize },
        156usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_ping)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stat) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stat)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_server_info) as usize - ptr as usize },
        164usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_server_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_server_version) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_server_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_host_info) as usize - ptr as usize },
        172usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_host_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_proto_info) as usize - ptr as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_proto_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_list_dbs) as usize - ptr as usize },
        180usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_list_dbs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_list_tables) as usize - ptr as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_list_tables)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_list_fields) as usize - ptr as usize },
        188usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_list_fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_list_processes) as usize - ptr as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_list_processes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_store_result) as usize - ptr as usize },
        196usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_store_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_use_result) as usize - ptr as usize },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_use_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_options) as usize - ptr as usize },
        204usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_options)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_free_result) as usize - ptr as usize },
        208usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_free_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_data_seek) as usize - ptr as usize },
        212usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_data_seek)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_row_seek) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_row_seek)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_field_seek) as usize - ptr as usize },
        220usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_field_seek)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_fetch_row) as usize - ptr as usize },
        224usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_fetch_row)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_fetch_lengths) as usize - ptr as usize },
        228usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_fetch_lengths)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_fetch_field) as usize - ptr as usize },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_fetch_field)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_escape_string) as usize - ptr as usize },
        236usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_escape_string)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_real_escape_string) as usize - ptr as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_real_escape_string)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_thread_safe) as usize - ptr as usize },
        244usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_thread_safe)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_warning_count) as usize - ptr as usize },
        248usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_warning_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_sqlstate) as usize - ptr as usize },
        252usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_sqlstate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_server_init) as usize - ptr as usize },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_server_init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_server_end) as usize - ptr as usize },
        260usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_server_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_thread_end) as usize - ptr as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_thread_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_thread_init) as usize - ptr as usize },
        268usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_thread_init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_set_server_option) as usize - ptr as usize },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_set_server_option)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_client_info) as usize - ptr as usize },
        276usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_client_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_client_version) as usize - ptr as usize },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_client_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_connection) as usize - ptr as usize },
        284usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_connection)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_server_name) as usize - ptr as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_server_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_get_charset_by_name) as usize - ptr as usize },
        292usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_get_charset_by_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_get_charset_by_nr) as usize - ptr as usize },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_get_charset_by_nr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_convert_string) as usize - ptr as usize },
        300usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_convert_string)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_optionsv) as usize - ptr as usize },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_optionsv)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_optionv) as usize - ptr as usize },
        308usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_optionv)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_option) as usize - ptr as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_option)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_hex_string) as usize - ptr as usize },
        316usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_hex_string)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_socket) as usize - ptr as usize },
        320usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_socket)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_timeout_value) as usize - ptr as usize },
        324usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_timeout_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_get_timeout_value_ms) as usize - ptr as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_get_timeout_value_ms)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_reconnect) as usize - ptr as usize },
        332usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_reconnect)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_init) as usize - ptr as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_prepare) as usize - ptr as usize },
        340usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_prepare)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_execute) as usize - ptr as usize },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_execute)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_fetch) as usize - ptr as usize },
        348usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_fetch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_fetch_column) as usize - ptr as usize },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_fetch_column)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_store_result) as usize - ptr as usize },
        356usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_store_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_param_count) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_param_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_attr_set) as usize - ptr as usize },
        364usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_attr_set)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_attr_get) as usize - ptr as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_attr_get)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_bind_param) as usize - ptr as usize },
        372usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_bind_param)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_bind_result) as usize - ptr as usize },
        376usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_bind_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_close) as usize - ptr as usize },
        380usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_close)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_reset) as usize - ptr as usize },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_reset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_free_result) as usize - ptr as usize },
        388usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_free_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_send_long_data) as usize - ptr as usize },
        392usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_send_long_data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_result_metadata) as usize - ptr as usize },
        396usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_result_metadata)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_param_metadata) as usize - ptr as usize },
        400usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_param_metadata)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_errno) as usize - ptr as usize },
        404usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_errno)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_error) as usize - ptr as usize },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_sqlstate) as usize - ptr as usize },
        412usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_sqlstate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_row_seek) as usize - ptr as usize },
        416usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_row_seek)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_row_tell) as usize - ptr as usize },
        420usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_row_tell)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_data_seek) as usize - ptr as usize },
        424usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_data_seek)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_num_rows) as usize - ptr as usize },
        428usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_num_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_affected_rows) as usize - ptr as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_affected_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_insert_id) as usize - ptr as usize },
        436usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_insert_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_field_count) as usize - ptr as usize },
        440usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_field_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_next_result) as usize - ptr as usize },
        444usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_next_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_stmt_more_results) as usize - ptr as usize },
        448usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_stmt_more_results)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mariadb_stmt_execute_direct) as usize - ptr as usize },
        452usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mariadb_stmt_execute_direct)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mysql_reset_connection) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_api),
            "::",
            stringify!(mysql_reset_connection)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mariadb_methods {
    pub db_connect: ::std::option::Option<
        unsafe extern "C" fn(
            mysql: *mut MYSQL,
            host: *const ::std::os::raw::c_char,
            user: *const ::std::os::raw::c_char,
            passwd: *const ::std::os::raw::c_char,
            db: *const ::std::os::raw::c_char,
            port: ::std::os::raw::c_uint,
            unix_socket: *const ::std::os::raw::c_char,
            clientflag: ::std::os::raw::c_ulong,
        ) -> *mut MYSQL,
    >,
    pub db_close: ::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL)>,
    pub db_command: ::std::option::Option<
        unsafe extern "C" fn(
            mysql: *mut MYSQL,
            command: enum_server_command,
            arg: *const ::std::os::raw::c_char,
            length: usize,
            skip_check: my_bool,
            opt_arg: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub db_skip_result: ::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL)>,
    pub db_read_query_result:
        ::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int>,
    pub db_read_rows: ::std::option::Option<
        unsafe extern "C" fn(
            mysql: *mut MYSQL,
            fields: *mut MYSQL_FIELD,
            field_count: ::std::os::raw::c_uint,
        ) -> *mut MYSQL_DATA,
    >,
    pub db_read_one_row: ::std::option::Option<
        unsafe extern "C" fn(
            mysql: *mut MYSQL,
            fields: ::std::os::raw::c_uint,
            row: MYSQL_ROW,
            lengths: *mut ::std::os::raw::c_ulong,
        ) -> ::std::os::raw::c_int,
    >,
    pub db_supported_buffer_type:
        ::std::option::Option<unsafe extern "C" fn(type_: enum_field_types) -> my_bool>,
    pub db_read_prepare_response:
        ::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
    pub db_read_stmt_result:
        ::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int>,
    pub db_stmt_get_result_metadata:
        ::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
    pub db_stmt_get_param_metadata:
        ::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
    pub db_stmt_read_all_rows:
        ::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int>,
    pub db_stmt_fetch: ::std::option::Option<
        unsafe extern "C" fn(
            stmt: *mut MYSQL_STMT,
            row: *mut *mut ::std::os::raw::c_uchar,
        ) -> ::std::os::raw::c_int,
    >,
    pub db_stmt_fetch_to_bind: ::std::option::Option<
        unsafe extern "C" fn(
            stmt: *mut MYSQL_STMT,
            row: *mut ::std::os::raw::c_uchar,
        ) -> ::std::os::raw::c_int,
    >,
    pub db_stmt_flush_unbuffered:
        ::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT)>,
    pub set_error: ::std::option::Option<
        unsafe extern "C" fn(
            mysql: *mut MYSQL,
            error_nr: ::std::os::raw::c_uint,
            sqlstate: *const ::std::os::raw::c_char,
            format: *const ::std::os::raw::c_char,
            ...
        ),
    >,
    pub invalidate_stmts: ::std::option::Option<
        unsafe extern "C" fn(mysql: *mut MYSQL, function_name: *const ::std::os::raw::c_char),
    >,
    pub api: *mut st_mariadb_api,
    pub db_read_execute_response:
        ::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int>,
    pub db_execute_generate_request: ::std::option::Option<
        unsafe extern "C" fn(
            stmt: *mut MYSQL_STMT,
            request_len: *mut usize,
            internal: my_bool,
        ) -> *mut ::std::os::raw::c_uchar,
    >,
}
#[test]
fn bindgen_test_layout_st_mariadb_methods() {
    const UNINIT: ::std::mem::MaybeUninit<st_mariadb_methods> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<st_mariadb_methods>(),
        84usize,
        concat!("Size of: ", stringify!(st_mariadb_methods))
    );
    assert_eq!(
        ::std::mem::align_of::<st_mariadb_methods>(),
        4usize,
        concat!("Alignment of ", stringify!(st_mariadb_methods))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_connect) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_connect)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_close) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_close)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_command) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_command)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_skip_result) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_skip_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_read_query_result) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_read_query_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_read_rows) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_read_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_read_one_row) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_read_one_row)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_supported_buffer_type) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_supported_buffer_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_read_prepare_response) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_read_prepare_response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_read_stmt_result) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_read_stmt_result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_stmt_get_result_metadata) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_stmt_get_result_metadata)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_stmt_get_param_metadata) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_stmt_get_param_metadata)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_stmt_read_all_rows) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_stmt_read_all_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_stmt_fetch) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_stmt_fetch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_stmt_fetch_to_bind) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_stmt_fetch_to_bind)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_stmt_flush_unbuffered) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_stmt_flush_unbuffered)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).set_error) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(set_error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).invalidate_stmts) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(invalidate_stmts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).api) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(api)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_read_execute_response) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_read_execute_response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db_execute_generate_request) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(st_mariadb_methods),
            "::",
            stringify!(db_execute_generate_request)
        )
    );
}
pub type __builtin_va_list = *mut ::std::os::raw::c_char;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mariadb_net_extension {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_dynamic_array {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mysql_options_extension {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mariadb_extension {
    pub _address: u8,
}