Skip to content

Instantly share code, notes, and snippets.

@BlackDex

BlackDex/bindings_mariadb_10_08_armv6_linux.rs

Created June 11, 2024 09:18
Show Gist options
  • Save BlackDex/6caec8fefc115a4e8baebd89b227f63b to your computer and use it in GitHub Desktop.
Save BlackDex/6caec8fefc115a4e8baebd89b227f63b to your computer and use it in GitHub Desktop.
Download ZIP
Raw
bindings_mariadb_10_08_armv6_linux.rs
/* automatically generated by rust-bindgen 0.69.4 */
pub const MYSQL_AUTODETECT_CHARSET_NAME: &[u8; 5] = b"auto\0";
pub const MYSQL_ERRMSG_SIZE: u32 = 512;
pub const MYSQL50_TABLE_NAME_PREFIX: &[u8; 10] = b"#mysql50#\0";
pub const MYSQL_UNIX_ADDR: &[u8; 16] = b"/tmp/mysql.sock\0";
pub const MYSQL_PORT: u32 = 3306;
pub const MYSQL_CONFIG_NAME: &[u8; 3] = b"my\0";
pub const MYSQL_VERSION_ID: u32 = 100808;
pub const MYSQL_SERVER_VERSION: &[u8; 15] = b"10.8.8-MariaDB\0";
pub const MYSQL_CHARSET: &[u8; 1] = b"\0";
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 = u32;
pub type my_bool = ::std::os::raw::c_char;
pub type my_ulonglong = ::std::os::raw::c_ulonglong;
pub type my_socket = ::std::os::raw::c_int;
#[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: my_socket,
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,
}
#[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_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(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 "C" {
pub fn mysql_stmt_init(mysql: *mut MYSQL) -> *mut MYSQL_STMT;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_execute(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_stmt_fetch(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_store_result(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_stmt_param_count(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulong;
}
extern "C" {
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 "C" {
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 "C" {
pub fn mysql_stmt_bind_param(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool;
}
extern "C" {
pub fn mysql_stmt_bind_result(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool;
}
extern "C" {
pub fn mysql_stmt_close(stmt: *mut MYSQL_STMT) -> my_bool;
}
extern "C" {
pub fn mysql_stmt_reset(stmt: *mut MYSQL_STMT) -> my_bool;
}
extern "C" {
pub fn mysql_stmt_free_result(stmt: *mut MYSQL_STMT) -> my_bool;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_result_metadata(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES;
}
extern "C" {
pub fn mysql_stmt_param_metadata(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES;
}
extern "C" {
pub fn mysql_stmt_errno(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_stmt_error(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_stmt_sqlstate(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_stmt_row_seek(stmt: *mut MYSQL_STMT, offset: MYSQL_ROW_OFFSET)
-> MYSQL_ROW_OFFSET;
}
extern "C" {
pub fn mysql_stmt_row_tell(stmt: *mut MYSQL_STMT) -> MYSQL_ROW_OFFSET;
}
extern "C" {
pub fn mysql_stmt_data_seek(stmt: *mut MYSQL_STMT, offset: ::std::os::raw::c_ulonglong);
}
extern "C" {
pub fn mysql_stmt_num_rows(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn mysql_stmt_affected_rows(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn mysql_stmt_insert_id(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn mysql_stmt_field_count(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_stmt_next_result(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_stmt_more_results(stmt: *mut MYSQL_STMT) -> my_bool;
}
#[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 "C" {
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 "C" {
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 "C" {
pub fn mysql_client_register_plugin(
mysql: *mut st_mysql,
plugin: *mut st_mysql_client_plugin,
) -> *mut st_mysql_client_plugin;
}
extern "C" {
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 "C" {
pub fn mysql_num_rows(res: *mut MYSQL_RES) -> my_ulonglong;
}
extern "C" {
pub fn mysql_num_fields(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_eof(res: *mut MYSQL_RES) -> my_bool;
}
extern "C" {
pub fn mysql_fetch_field_direct(
res: *mut MYSQL_RES,
fieldnr: ::std::os::raw::c_uint,
) -> *mut MYSQL_FIELD;
}
extern "C" {
pub fn mysql_fetch_fields(res: *mut MYSQL_RES) -> *mut MYSQL_FIELD;
}
extern "C" {
pub fn mysql_row_tell(res: *mut MYSQL_RES) -> *mut MYSQL_ROWS;
}
extern "C" {
pub fn mysql_field_tell(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_field_count(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_more_results(mysql: *mut MYSQL) -> my_bool;
}
extern "C" {
pub fn mysql_next_result(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_affected_rows(mysql: *mut MYSQL) -> my_ulonglong;
}
extern "C" {
pub fn mysql_autocommit(mysql: *mut MYSQL, mode: my_bool) -> my_bool;
}
extern "C" {
pub fn mysql_commit(mysql: *mut MYSQL) -> my_bool;
}
extern "C" {
pub fn mysql_rollback(mysql: *mut MYSQL) -> my_bool;
}
extern "C" {
pub fn mysql_insert_id(mysql: *mut MYSQL) -> my_ulonglong;
}
extern "C" {
pub fn mysql_errno(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_error(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_info(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_thread_id(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn mysql_character_set_name(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_get_character_set_info(mysql: *mut MYSQL, cs: *mut MY_CHARSET_INFO);
}
extern "C" {
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 mysql_init(mysql: *mut MYSQL) -> *mut MYSQL;
}
extern "C" {
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 "C" {
pub fn mysql_get_ssl_cipher(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "C" {
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 "C" {
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 "C" {
pub fn mysql_close(sock: *mut MYSQL);
}
extern "C" {
pub fn mysql_select_db(
mysql: *mut MYSQL,
db: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_query(
mysql: *mut MYSQL,
q: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_read_query_result(mysql: *mut MYSQL) -> my_bool;
}
extern "C" {
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 "C" {
pub fn mysql_shutdown(
mysql: *mut MYSQL,
shutdown_level: mysql_enum_shutdown_level,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_dump_debug_info(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_refresh(
mysql: *mut MYSQL,
refresh_options: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_kill(mysql: *mut MYSQL, pid: ::std::os::raw::c_ulong) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_ping(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_stat(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_get_server_info(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_get_server_version(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn mysql_get_host_info(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_get_proto_info(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_list_dbs(mysql: *mut MYSQL, wild: *const ::std::os::raw::c_char)
-> *mut MYSQL_RES;
}
extern "C" {
pub fn mysql_list_tables(
mysql: *mut MYSQL,
wild: *const ::std::os::raw::c_char,
) -> *mut MYSQL_RES;
}
extern "C" {
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 "C" {
pub fn mysql_list_processes(mysql: *mut MYSQL) -> *mut MYSQL_RES;
}
extern "C" {
pub fn mysql_store_result(mysql: *mut MYSQL) -> *mut MYSQL_RES;
}
extern "C" {
pub fn mysql_use_result(mysql: *mut MYSQL) -> *mut MYSQL_RES;
}
extern "C" {
pub fn mysql_options(
mysql: *mut MYSQL,
option: mysql_option,
arg: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_free_result(result: *mut MYSQL_RES);
}
extern "C" {
pub fn mysql_data_seek(result: *mut MYSQL_RES, offset: ::std::os::raw::c_ulonglong);
}
extern "C" {
pub fn mysql_row_seek(result: *mut MYSQL_RES, arg1: MYSQL_ROW_OFFSET) -> MYSQL_ROW_OFFSET;
}
extern "C" {
pub fn mysql_field_seek(
result: *mut MYSQL_RES,
offset: MYSQL_FIELD_OFFSET,
) -> MYSQL_FIELD_OFFSET;
}
extern "C" {
pub fn mysql_fetch_row(result: *mut MYSQL_RES) -> MYSQL_ROW;
}
extern "C" {
pub fn mysql_fetch_lengths(result: *mut MYSQL_RES) -> *mut ::std::os::raw::c_ulong;
}
extern "C" {
pub fn mysql_fetch_field(result: *mut MYSQL_RES) -> *mut MYSQL_FIELD;
}
extern "C" {
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 "C" {
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 "C" {
pub fn mysql_thread_safe() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_warning_count(mysql: *mut MYSQL) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_sqlstate(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
extern "C" {
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 "C" {
pub fn mysql_server_end();
}
extern "C" {
pub fn mysql_thread_end();
}
extern "C" {
pub fn mysql_thread_init() -> my_bool;
}
extern "C" {
pub fn mysql_set_server_option(
mysql: *mut MYSQL,
option: enum_mysql_set_option,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_get_client_info() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mysql_get_client_version() -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn mysql_get_server_name(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char;
}
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 "C" {
pub fn mysql_get_option(
mysql: *mut MYSQL,
option: mysql_option,
arg: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_get_socket(mysql: *mut MYSQL) -> my_socket;
}
extern "C" {
pub fn mysql_get_timeout_value(mysql: *const MYSQL) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_get_timeout_value_ms(mysql: *const MYSQL) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn mysql_debug(debug: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn mysql_net_read_packet(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn mysql_net_field_length(
packet: *mut *mut ::std::os::raw::c_uchar,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn mysql_embedded() -> my_bool;
}
extern "C" {
pub fn mysql_get_parameters() -> *mut MYSQL_PARAMETERS;
}
extern "C" {
pub fn mysql_close_start(sock: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_close_cont(
sock: *mut MYSQL,
status: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_commit_start(ret: *mut my_bool, mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_commit_cont(
ret: *mut my_bool,
mysql: *mut MYSQL,
status: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_dump_debug_info_start(
ret: *mut ::std::os::raw::c_int,
mysql: *mut MYSQL,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_rollback_start(ret: *mut my_bool, mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_rollback_cont(
ret: *mut my_bool,
mysql: *mut MYSQL,
status: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_autocommit_start(
ret: *mut my_bool,
mysql: *mut MYSQL,
auto_mode: my_bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
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 "C" {
pub fn mysql_autocommit_cont(
ret: *mut my_bool,
mysql: *mut MYSQL,
status: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_next_result_start(
ret: *mut ::std::os::raw::c_int,
mysql: *mut MYSQL,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
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 "C" {
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 "C" {
pub fn mysql_stmt_warning_count(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_stmt_next_result_start(
ret: *mut ::std::os::raw::c_int,
stmt: *mut MYSQL_STMT,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
pub fn mysql_store_result_start(
ret: *mut *mut MYSQL_RES,
mysql: *mut MYSQL,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
pub fn mysql_ping_start(
ret: *mut ::std::os::raw::c_int,
mysql: *mut MYSQL,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_stat_start(
ret: *mut *const ::std::os::raw::c_char,
mysql: *mut MYSQL,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_free_result_start(result: *mut MYSQL_RES) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_free_result_cont(
result: *mut MYSQL_RES,
status: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mysql_fetch_row_start(
ret: *mut MYSQL_ROW,
result: *mut MYSQL_RES,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_read_query_result_start(
ret: *mut my_bool,
mysql: *mut MYSQL,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_reset_connection_start(
ret: *mut ::std::os::raw::c_int,
mysql: *mut MYSQL,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
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 "C" {
pub fn mysql_stmt_execute_start(
ret: *mut ::std::os::raw::c_int,
stmt: *mut MYSQL_STMT,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_fetch_start(
ret: *mut ::std::os::raw::c_int,
stmt: *mut MYSQL_STMT,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_store_result_start(
ret: *mut ::std::os::raw::c_int,
stmt: *mut MYSQL_STMT,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_close_start(
ret: *mut my_bool,
stmt: *mut MYSQL_STMT,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_reset_start(
ret: *mut my_bool,
stmt: *mut MYSQL_STMT,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
pub fn mysql_stmt_free_result_start(
ret: *mut my_bool,
stmt: *mut MYSQL_STMT,
) -> ::std::os::raw::c_int;
}
extern "C" {
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 "C" {
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 "C" {
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 "C" {
pub fn mysql_reset_connection(mysql: *mut MYSQL) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_mariadb_api {
pub mysql_num_rows: ::std::option::Option<
unsafe extern "C" fn(res: *mut MYSQL_RES) -> ::std::os::raw::c_ulonglong,
>,
pub mysql_num_fields:
::std::option::Option<unsafe extern "C" fn(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint>,
pub mysql_eof: ::std::option::Option<unsafe extern "C" fn(res: *mut MYSQL_RES) -> my_bool>,
pub mysql_fetch_field_direct: ::std::option::Option<
unsafe extern "C" fn(
res: *mut MYSQL_RES,
fieldnr: ::std::os::raw::c_uint,
) -> *mut MYSQL_FIELD,
>,
pub mysql_fetch_fields:
::std::option::Option<unsafe extern "C" fn(res: *mut MYSQL_RES) -> *mut MYSQL_FIELD>,
pub mysql_row_tell:
::std::option::Option<unsafe extern "C" fn(res: *mut MYSQL_RES) -> *mut MYSQL_ROWS>,
pub mysql_field_tell:
::std::option::Option<unsafe extern "C" fn(res: *mut MYSQL_RES) -> ::std::os::raw::c_uint>,
pub mysql_field_count:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint>,
pub mysql_more_results:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> my_bool>,
pub mysql_next_result:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int>,
pub mysql_affected_rows: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulonglong,
>,
pub mysql_autocommit:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL, mode: my_bool) -> my_bool>,
pub mysql_commit: ::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> my_bool>,
pub mysql_rollback: ::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> my_bool>,
pub mysql_insert_id: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulonglong,
>,
pub mysql_errno:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint>,
pub mysql_error: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
>,
pub mysql_info: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
>,
pub mysql_thread_id:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong>,
pub mysql_character_set_name: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
>,
pub mysql_get_character_set_info:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL, cs: *mut MY_CHARSET_INFO)>,
pub mysql_set_character_set: ::std::option::Option<
unsafe extern "C" 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 "C" fn(
mysql: *mut MYSQL,
value: mariadb_value,
arg: *mut ::std::os::raw::c_void,
) -> my_bool,
>,
pub mysql_init: ::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> *mut MYSQL>,
pub mysql_ssl_set: ::std::option::Option<
unsafe extern "C" 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 "C" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
>,
pub mysql_change_user: ::std::option::Option<
unsafe extern "C" 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 "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 mysql_close: ::std::option::Option<unsafe extern "C" fn(sock: *mut MYSQL)>,
pub mysql_select_db: ::std::option::Option<
unsafe extern "C" fn(
mysql: *mut MYSQL,
db: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int,
>,
pub mysql_query: ::std::option::Option<
unsafe extern "C" 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 "C" 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 "C" fn(mysql: *mut MYSQL) -> my_bool>,
pub mysql_real_query: ::std::option::Option<
unsafe extern "C" 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 "C" 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 "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int>,
pub mysql_refresh: ::std::option::Option<
unsafe extern "C" fn(
mysql: *mut MYSQL,
refresh_options: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int,
>,
pub mysql_kill: ::std::option::Option<
unsafe extern "C" fn(
mysql: *mut MYSQL,
pid: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int,
>,
pub mysql_ping:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_int>,
pub mysql_stat: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char,
>,
pub mysql_get_server_info: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char,
>,
pub mysql_get_server_version:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_ulong>,
pub mysql_get_host_info: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *mut ::std::os::raw::c_char,
>,
pub mysql_get_proto_info:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint>,
pub mysql_list_dbs: ::std::option::Option<
unsafe extern "C" fn(
mysql: *mut MYSQL,
wild: *const ::std::os::raw::c_char,
) -> *mut MYSQL_RES,
>,
pub mysql_list_tables: ::std::option::Option<
unsafe extern "C" fn(
mysql: *mut MYSQL,
wild: *const ::std::os::raw::c_char,
) -> *mut MYSQL_RES,
>,
pub mysql_list_fields: ::std::option::Option<
unsafe extern "C" 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 "C" fn(mysql: *mut MYSQL) -> *mut MYSQL_RES>,
pub mysql_store_result:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> *mut MYSQL_RES>,
pub mysql_use_result:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> *mut MYSQL_RES>,
pub mysql_options: ::std::option::Option<
unsafe extern "C" 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 "C" fn(result: *mut MYSQL_RES)>,
pub mysql_data_seek: ::std::option::Option<
unsafe extern "C" fn(result: *mut MYSQL_RES, offset: ::std::os::raw::c_ulonglong),
>,
pub mysql_row_seek: ::std::option::Option<
unsafe extern "C" fn(result: *mut MYSQL_RES, arg1: MYSQL_ROW_OFFSET) -> MYSQL_ROW_OFFSET,
>,
pub mysql_field_seek: ::std::option::Option<
unsafe extern "C" fn(
result: *mut MYSQL_RES,
offset: MYSQL_FIELD_OFFSET,
) -> MYSQL_FIELD_OFFSET,
>,
pub mysql_fetch_row:
::std::option::Option<unsafe extern "C" fn(result: *mut MYSQL_RES) -> MYSQL_ROW>,
pub mysql_fetch_lengths: ::std::option::Option<
unsafe extern "C" fn(result: *mut MYSQL_RES) -> *mut ::std::os::raw::c_ulong,
>,
pub mysql_fetch_field:
::std::option::Option<unsafe extern "C" fn(result: *mut MYSQL_RES) -> *mut MYSQL_FIELD>,
pub mysql_escape_string: ::std::option::Option<
unsafe extern "C" 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 "C" 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 "C" fn() -> ::std::os::raw::c_uint>,
pub mysql_warning_count:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> ::std::os::raw::c_uint>,
pub mysql_sqlstate: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
>,
pub mysql_server_init: ::std::option::Option<
unsafe extern "C" 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 "C" fn()>,
pub mysql_thread_end: ::std::option::Option<unsafe extern "C" fn()>,
pub mysql_thread_init: ::std::option::Option<unsafe extern "C" fn() -> my_bool>,
pub mysql_set_server_option: ::std::option::Option<
unsafe extern "C" fn(
mysql: *mut MYSQL,
option: enum_mysql_set_option,
) -> ::std::os::raw::c_int,
>,
pub mysql_get_client_info:
::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>,
pub mysql_get_client_version:
::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_ulong>,
pub mariadb_connection:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> my_bool>,
pub mysql_get_server_name: ::std::option::Option<
unsafe extern "C" fn(mysql: *mut MYSQL) -> *const ::std::os::raw::c_char,
>,
pub mariadb_get_charset_by_name: ::std::option::Option<
unsafe extern "C" fn(csname: *const ::std::os::raw::c_char) -> *mut MARIADB_CHARSET_INFO,
>,
pub mariadb_get_charset_by_nr: ::std::option::Option<
unsafe extern "C" fn(csnr: ::std::os::raw::c_uint) -> *mut MARIADB_CHARSET_INFO,
>,
pub mariadb_convert_string: ::std::option::Option<
unsafe extern "C" 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 "C" 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 "C" 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 "C" fn(mysql: *mut MYSQL) -> my_socket>,
pub mysql_get_timeout_value:
::std::option::Option<unsafe extern "C" fn(mysql: *const MYSQL) -> ::std::os::raw::c_uint>,
pub mysql_get_timeout_value_ms:
::std::option::Option<unsafe extern "C" fn(mysql: *const MYSQL) -> ::std::os::raw::c_uint>,
pub mariadb_reconnect:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> my_bool>,
pub mysql_stmt_init:
::std::option::Option<unsafe extern "C" fn(mysql: *mut MYSQL) -> *mut MYSQL_STMT>,
pub mysql_stmt_prepare: ::std::option::Option<
unsafe extern "C" 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 "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int>,
pub mysql_stmt_fetch:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int>,
pub mysql_stmt_fetch_column: ::std::option::Option<
unsafe extern "C" 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 "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int>,
pub mysql_stmt_param_count: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulong,
>,
pub mysql_stmt_attr_set: ::std::option::Option<
unsafe extern "C" 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 "C" 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 "C" fn(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool,
>,
pub mysql_stmt_bind_result: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT, bnd: *mut MYSQL_BIND) -> my_bool,
>,
pub mysql_stmt_close:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
pub mysql_stmt_reset:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
pub mysql_stmt_free_result:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
pub mysql_stmt_send_long_data: ::std::option::Option<
unsafe extern "C" 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 "C" fn(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES>,
pub mysql_stmt_param_metadata:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> *mut MYSQL_RES>,
pub mysql_stmt_errno: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint,
>,
pub mysql_stmt_error: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char,
>,
pub mysql_stmt_sqlstate: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> *const ::std::os::raw::c_char,
>,
pub mysql_stmt_row_seek: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT, offset: MYSQL_ROW_OFFSET) -> MYSQL_ROW_OFFSET,
>,
pub mysql_stmt_row_tell:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> MYSQL_ROW_OFFSET>,
pub mysql_stmt_data_seek: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT, offset: ::std::os::raw::c_ulonglong),
>,
pub mysql_stmt_num_rows: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong,
>,
pub mysql_stmt_affected_rows: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong,
>,
pub mysql_stmt_insert_id: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_ulonglong,
>,
pub mysql_stmt_field_count: ::std::option::Option<
unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_uint,
>,
pub mysql_stmt_next_result:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> ::std::os::raw::c_int>,
pub mysql_stmt_more_results:
::std::option::Option<unsafe extern "C" fn(stmt: *mut MYSQL_STMT) -> my_bool>,
pub mariadb_stmt_execute_direct: ::std::option::Option<
unsafe extern "C" 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 "C" 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)
)
);
}
#[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,
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment