Created
June 11, 2024 09:18
-
-
Save BlackDex/6caec8fefc115a4e8baebd89b227f63b to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* 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