odpic_sys/

bindings.rs

/* automatically generated by rust-bindgen 0.70.1 */

pub const DPI_MAJOR_VERSION: u32 = 5;
pub const DPI_MINOR_VERSION: u32 = 4;
pub const DPI_PATCH_LEVEL: u32 = 1;
pub const DPI_DEFAULT_FETCH_ARRAY_SIZE: u32 = 100;
pub const DPI_DEFAULT_PREFETCH_ROWS: u32 = 2;
pub const DPI_DEFAULT_PING_INTERVAL: u32 = 60;
pub const DPI_DEFAULT_PING_TIMEOUT: u32 = 5000;
pub const DPI_DEFAULT_STMT_CACHE_SIZE: u32 = 20;
pub const DPI_DEQ_WAIT_NO_WAIT: u32 = 0;
pub const DPI_MAX_INT64_PRECISION: u32 = 18;
pub const DPI_SUCCESS: u32 = 0;
pub const DPI_FAILURE: i32 = -1;
pub const DPI_DEBUG_LEVEL_UNREPORTED_ERRORS: u32 = 1;
pub const DPI_DEBUG_LEVEL_REFS: u32 = 2;
pub const DPI_DEBUG_LEVEL_FNS: u32 = 4;
pub const DPI_DEBUG_LEVEL_ERRORS: u32 = 8;
pub const DPI_DEBUG_LEVEL_SQL: u32 = 16;
pub const DPI_DEBUG_LEVEL_MEM: u32 = 32;
pub const DPI_DEBUG_LEVEL_LOAD_LIB: u32 = 64;
pub const DPI_MODE_AUTH_DEFAULT: u32 = 0;
pub const DPI_MODE_AUTH_SYSDBA: u32 = 2;
pub const DPI_MODE_AUTH_SYSOPER: u32 = 4;
pub const DPI_MODE_AUTH_PRELIM: u32 = 8;
pub const DPI_MODE_AUTH_SYSASM: u32 = 32768;
pub const DPI_MODE_AUTH_SYSBKP: u32 = 131072;
pub const DPI_MODE_AUTH_SYSDGD: u32 = 262144;
pub const DPI_MODE_AUTH_SYSKMT: u32 = 524288;
pub const DPI_MODE_AUTH_SYSRAC: u32 = 1048576;
pub const DPI_MODE_CONN_CLOSE_DEFAULT: u32 = 0;
pub const DPI_MODE_CONN_CLOSE_DROP: u32 = 1;
pub const DPI_MODE_CONN_CLOSE_RETAG: u32 = 2;
pub const DPI_MODE_CREATE_DEFAULT: u32 = 0;
pub const DPI_MODE_CREATE_THREADED: u32 = 1;
pub const DPI_MODE_CREATE_EVENTS: u32 = 4;
pub const DPI_MODE_DEQ_BROWSE: u32 = 1;
pub const DPI_MODE_DEQ_LOCKED: u32 = 2;
pub const DPI_MODE_DEQ_REMOVE: u32 = 3;
pub const DPI_MODE_DEQ_REMOVE_NO_DATA: u32 = 4;
pub const DPI_DEQ_NAV_FIRST_MSG: u32 = 1;
pub const DPI_DEQ_NAV_NEXT_TRANSACTION: u32 = 2;
pub const DPI_DEQ_NAV_NEXT_MSG: u32 = 3;
pub const DPI_EVENT_NONE: u32 = 0;
pub const DPI_EVENT_STARTUP: u32 = 1;
pub const DPI_EVENT_SHUTDOWN: u32 = 2;
pub const DPI_EVENT_SHUTDOWN_ANY: u32 = 3;
pub const DPI_EVENT_DEREG: u32 = 5;
pub const DPI_EVENT_OBJCHANGE: u32 = 6;
pub const DPI_EVENT_QUERYCHANGE: u32 = 7;
pub const DPI_EVENT_AQ: u32 = 100;
pub const DPI_JSON_OPT_DEFAULT: u32 = 0;
pub const DPI_JSON_OPT_NUMBER_AS_STRING: u32 = 1;
pub const DPI_JSON_OPT_DATE_AS_DOUBLE: u32 = 2;
pub const DPI_MODE_EXEC_DEFAULT: u32 = 0;
pub const DPI_MODE_EXEC_DESCRIBE_ONLY: u32 = 16;
pub const DPI_MODE_EXEC_COMMIT_ON_SUCCESS: u32 = 32;
pub const DPI_MODE_EXEC_BATCH_ERRORS: u32 = 128;
pub const DPI_MODE_EXEC_PARSE_ONLY: u32 = 256;
pub const DPI_MODE_EXEC_ARRAY_DML_ROWCOUNTS: u32 = 1048576;
pub const DPI_MODE_FETCH_NEXT: u32 = 2;
pub const DPI_MODE_FETCH_FIRST: u32 = 4;
pub const DPI_MODE_FETCH_LAST: u32 = 8;
pub const DPI_MODE_FETCH_PRIOR: u32 = 16;
pub const DPI_MODE_FETCH_ABSOLUTE: u32 = 32;
pub const DPI_MODE_FETCH_RELATIVE: u32 = 64;
pub const DPI_MODE_MSG_PERSISTENT: u32 = 1;
pub const DPI_MODE_MSG_BUFFERED: u32 = 2;
pub const DPI_MODE_MSG_PERSISTENT_OR_BUFFERED: u32 = 3;
pub const DPI_MSG_STATE_READY: u32 = 0;
pub const DPI_MSG_STATE_WAITING: u32 = 1;
pub const DPI_MSG_STATE_PROCESSED: u32 = 2;
pub const DPI_MSG_STATE_EXPIRED: u32 = 3;
pub const DPI_NATIVE_TYPE_INT64: u32 = 3000;
pub const DPI_NATIVE_TYPE_UINT64: u32 = 3001;
pub const DPI_NATIVE_TYPE_FLOAT: u32 = 3002;
pub const DPI_NATIVE_TYPE_DOUBLE: u32 = 3003;
pub const DPI_NATIVE_TYPE_BYTES: u32 = 3004;
pub const DPI_NATIVE_TYPE_TIMESTAMP: u32 = 3005;
pub const DPI_NATIVE_TYPE_INTERVAL_DS: u32 = 3006;
pub const DPI_NATIVE_TYPE_INTERVAL_YM: u32 = 3007;
pub const DPI_NATIVE_TYPE_LOB: u32 = 3008;
pub const DPI_NATIVE_TYPE_OBJECT: u32 = 3009;
pub const DPI_NATIVE_TYPE_STMT: u32 = 3010;
pub const DPI_NATIVE_TYPE_BOOLEAN: u32 = 3011;
pub const DPI_NATIVE_TYPE_ROWID: u32 = 3012;
pub const DPI_NATIVE_TYPE_JSON: u32 = 3013;
pub const DPI_NATIVE_TYPE_JSON_OBJECT: u32 = 3014;
pub const DPI_NATIVE_TYPE_JSON_ARRAY: u32 = 3015;
pub const DPI_NATIVE_TYPE_NULL: u32 = 3016;
pub const DPI_NATIVE_TYPE_VECTOR: u32 = 3017;
pub const DPI_OPCODE_ALL_OPS: u32 = 0;
pub const DPI_OPCODE_ALL_ROWS: u32 = 1;
pub const DPI_OPCODE_INSERT: u32 = 2;
pub const DPI_OPCODE_UPDATE: u32 = 4;
pub const DPI_OPCODE_DELETE: u32 = 8;
pub const DPI_OPCODE_ALTER: u32 = 16;
pub const DPI_OPCODE_DROP: u32 = 32;
pub const DPI_OPCODE_UNKNOWN: u32 = 64;
pub const DPI_ORACLE_TYPE_NONE: u32 = 2000;
pub const DPI_ORACLE_TYPE_VARCHAR: u32 = 2001;
pub const DPI_ORACLE_TYPE_NVARCHAR: u32 = 2002;
pub const DPI_ORACLE_TYPE_CHAR: u32 = 2003;
pub const DPI_ORACLE_TYPE_NCHAR: u32 = 2004;
pub const DPI_ORACLE_TYPE_ROWID: u32 = 2005;
pub const DPI_ORACLE_TYPE_RAW: u32 = 2006;
pub const DPI_ORACLE_TYPE_NATIVE_FLOAT: u32 = 2007;
pub const DPI_ORACLE_TYPE_NATIVE_DOUBLE: u32 = 2008;
pub const DPI_ORACLE_TYPE_NATIVE_INT: u32 = 2009;
pub const DPI_ORACLE_TYPE_NUMBER: u32 = 2010;
pub const DPI_ORACLE_TYPE_DATE: u32 = 2011;
pub const DPI_ORACLE_TYPE_TIMESTAMP: u32 = 2012;
pub const DPI_ORACLE_TYPE_TIMESTAMP_TZ: u32 = 2013;
pub const DPI_ORACLE_TYPE_TIMESTAMP_LTZ: u32 = 2014;
pub const DPI_ORACLE_TYPE_INTERVAL_DS: u32 = 2015;
pub const DPI_ORACLE_TYPE_INTERVAL_YM: u32 = 2016;
pub const DPI_ORACLE_TYPE_CLOB: u32 = 2017;
pub const DPI_ORACLE_TYPE_NCLOB: u32 = 2018;
pub const DPI_ORACLE_TYPE_BLOB: u32 = 2019;
pub const DPI_ORACLE_TYPE_BFILE: u32 = 2020;
pub const DPI_ORACLE_TYPE_STMT: u32 = 2021;
pub const DPI_ORACLE_TYPE_BOOLEAN: u32 = 2022;
pub const DPI_ORACLE_TYPE_OBJECT: u32 = 2023;
pub const DPI_ORACLE_TYPE_LONG_VARCHAR: u32 = 2024;
pub const DPI_ORACLE_TYPE_LONG_RAW: u32 = 2025;
pub const DPI_ORACLE_TYPE_NATIVE_UINT: u32 = 2026;
pub const DPI_ORACLE_TYPE_JSON: u32 = 2027;
pub const DPI_ORACLE_TYPE_JSON_OBJECT: u32 = 2028;
pub const DPI_ORACLE_TYPE_JSON_ARRAY: u32 = 2029;
pub const DPI_ORACLE_TYPE_UROWID: u32 = 2030;
pub const DPI_ORACLE_TYPE_LONG_NVARCHAR: u32 = 2031;
pub const DPI_ORACLE_TYPE_XMLTYPE: u32 = 2032;
pub const DPI_ORACLE_TYPE_VECTOR: u32 = 2033;
pub const DPI_ORACLE_TYPE_JSON_ID: u32 = 2034;
pub const DPI_ORACLE_TYPE_MAX: u32 = 2035;
pub const DPI_MODE_POOL_CLOSE_DEFAULT: u32 = 0;
pub const DPI_MODE_POOL_CLOSE_FORCE: u32 = 1;
pub const DPI_MODE_POOL_GET_WAIT: u32 = 0;
pub const DPI_MODE_POOL_GET_NOWAIT: u32 = 1;
pub const DPI_MODE_POOL_GET_FORCEGET: u32 = 2;
pub const DPI_MODE_POOL_GET_TIMEDWAIT: u32 = 3;
pub const DPI_PURITY_DEFAULT: u32 = 0;
pub const DPI_PURITY_NEW: u32 = 1;
pub const DPI_PURITY_SELF: u32 = 2;
pub const DPI_MODE_SHUTDOWN_DEFAULT: u32 = 0;
pub const DPI_MODE_SHUTDOWN_TRANSACTIONAL: u32 = 1;
pub const DPI_MODE_SHUTDOWN_TRANSACTIONAL_LOCAL: u32 = 2;
pub const DPI_MODE_SHUTDOWN_IMMEDIATE: u32 = 3;
pub const DPI_MODE_SHUTDOWN_ABORT: u32 = 4;
pub const DPI_MODE_SHUTDOWN_FINAL: u32 = 5;
pub const DPI_SODA_FLAGS_DEFAULT: u32 = 0;
pub const DPI_SODA_FLAGS_ATOMIC_COMMIT: u32 = 1;
pub const DPI_SODA_FLAGS_CREATE_COLL_MAP: u32 = 2;
pub const DPI_SODA_FLAGS_INDEX_DROP_FORCE: u32 = 4;
pub const DPI_MODE_STARTUP_DEFAULT: u32 = 0;
pub const DPI_MODE_STARTUP_FORCE: u32 = 1;
pub const DPI_MODE_STARTUP_RESTRICT: u32 = 2;
pub const DPI_SERVER_TYPE_UNKNOWN: u32 = 0;
pub const DPI_SERVER_TYPE_DEDICATED: u32 = 1;
pub const DPI_SERVER_TYPE_SHARED: u32 = 2;
pub const DPI_SERVER_TYPE_POOLED: u32 = 4;
pub const DPI_STMT_TYPE_UNKNOWN: u32 = 0;
pub const DPI_STMT_TYPE_SELECT: u32 = 1;
pub const DPI_STMT_TYPE_UPDATE: u32 = 2;
pub const DPI_STMT_TYPE_DELETE: u32 = 3;
pub const DPI_STMT_TYPE_INSERT: u32 = 4;
pub const DPI_STMT_TYPE_CREATE: u32 = 5;
pub const DPI_STMT_TYPE_DROP: u32 = 6;
pub const DPI_STMT_TYPE_ALTER: u32 = 7;
pub const DPI_STMT_TYPE_BEGIN: u32 = 8;
pub const DPI_STMT_TYPE_DECLARE: u32 = 9;
pub const DPI_STMT_TYPE_CALL: u32 = 10;
pub const DPI_STMT_TYPE_EXPLAIN_PLAN: u32 = 15;
pub const DPI_STMT_TYPE_MERGE: u32 = 16;
pub const DPI_STMT_TYPE_ROLLBACK: u32 = 17;
pub const DPI_STMT_TYPE_COMMIT: u32 = 21;
pub const DPI_SUBSCR_GROUPING_CLASS_TIME: u32 = 1;
pub const DPI_SUBSCR_GROUPING_TYPE_SUMMARY: u32 = 1;
pub const DPI_SUBSCR_GROUPING_TYPE_LAST: u32 = 2;
pub const DPI_SUBSCR_NAMESPACE_AQ: u32 = 1;
pub const DPI_SUBSCR_NAMESPACE_DBCHANGE: u32 = 2;
pub const DPI_SUBSCR_PROTO_CALLBACK: u32 = 0;
pub const DPI_SUBSCR_PROTO_MAIL: u32 = 1;
pub const DPI_SUBSCR_PROTO_PLSQL: u32 = 2;
pub const DPI_SUBSCR_PROTO_HTTP: u32 = 3;
pub const DPI_SUBSCR_QOS_RELIABLE: u32 = 1;
pub const DPI_SUBSCR_QOS_DEREG_NFY: u32 = 2;
pub const DPI_SUBSCR_QOS_ROWIDS: u32 = 4;
pub const DPI_SUBSCR_QOS_QUERY: u32 = 8;
pub const DPI_SUBSCR_QOS_BEST_EFFORT: u32 = 16;
pub const DPI_TPC_BEGIN_JOIN: u32 = 2;
pub const DPI_TPC_BEGIN_NEW: u32 = 1;
pub const DPI_TPC_BEGIN_PROMOTE: u32 = 8;
pub const DPI_TPC_BEGIN_RESUME: u32 = 4;
pub const DPI_TPC_END_NORMAL: u32 = 0;
pub const DPI_TPC_END_SUSPEND: u32 = 1048576;
pub const DPI_VECTOR_FLAGS_FLEXIBLE_DIM: u32 = 1;
pub const DPI_VECTOR_FORMAT_FLOAT32: u32 = 2;
pub const DPI_VECTOR_FORMAT_FLOAT64: u32 = 3;
pub const DPI_VECTOR_FORMAT_INT8: u32 = 4;
pub const DPI_VECTOR_FORMAT_BINARY: u32 = 5;
pub const DPI_VISIBILITY_IMMEDIATE: u32 = 1;
pub const DPI_VISIBILITY_ON_COMMIT: u32 = 2;
pub type dpiAuthMode = u32;
pub type dpiConnCloseMode = u32;
pub type dpiCreateMode = u32;
pub type dpiDeqMode = u32;
pub type dpiDeqNavigation = u32;
pub type dpiEventType = u32;
pub type dpiExecMode = u32;
pub type dpiFetchMode = u16;
pub type dpiMessageDeliveryMode = u16;
pub type dpiMessageState = u32;
pub type dpiNativeTypeNum = u32;
pub type dpiOpCode = u32;
pub type dpiOracleTypeNum = u32;
pub type dpiPoolCloseMode = u32;
pub type dpiPoolGetMode = u8;
pub type dpiPurity = u32;
pub type dpiShutdownMode = u32;
pub type dpiStartupMode = u32;
pub type dpiServerType = u8;
pub type dpiStatementType = u16;
pub type dpiSubscrGroupingClass = u8;
pub type dpiSubscrGroupingType = u8;
pub type dpiSubscrNamespace = u32;
pub type dpiSubscrProtocol = u32;
pub type dpiSubscrQOS = u32;
pub type dpiTpcBeginFlags = u32;
pub type dpiTpcEndFlags = u32;
pub type dpiVectorFlags = u8;
pub type dpiVectorFormat = u8;
pub type dpiVisibility = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiConn {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiDeqOptions {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiEnqOptions {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiJson {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiLob {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiMsgProps {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObject {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObjectAttr {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObjectType {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiPool {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiQueue {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiRowid {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaColl {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaCollCursor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaDb {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaDoc {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaDocCursor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiStmt {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscr {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiVar {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiVector {
    _unused: [u8; 0],
}
pub type dpiSodaCollNames = dpiStringList;
pub type dpiAccessTokenCallback = ::std::option::Option<
    unsafe extern "C" fn(
        context: *mut ::std::os::raw::c_void,
        accessToken: *mut dpiAccessToken,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiBytes {
    pub ptr: *mut ::std::os::raw::c_char,
    pub length: u32,
    pub encoding: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dpiBytes() {
    const UNINIT: ::std::mem::MaybeUninit<dpiBytes> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiBytes>(),
        24usize,
        "Size of dpiBytes"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiBytes>(),
        8usize,
        "Alignment of dpiBytes"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiBytes::ptr"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiBytes::length"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiBytes::encoding"
    );
}
impl Default for dpiBytes {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct dpiIntervalDS {
    pub days: i32,
    pub hours: i32,
    pub minutes: i32,
    pub seconds: i32,
    pub fseconds: i32,
}
#[test]
fn bindgen_test_layout_dpiIntervalDS() {
    const UNINIT: ::std::mem::MaybeUninit<dpiIntervalDS> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiIntervalDS>(),
        20usize,
        "Size of dpiIntervalDS"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiIntervalDS>(),
        4usize,
        "Alignment of dpiIntervalDS"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).days) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiIntervalDS::days"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hours) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiIntervalDS::hours"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).minutes) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiIntervalDS::minutes"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seconds) as usize - ptr as usize },
        12usize,
        "Offset of field: dpiIntervalDS::seconds"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fseconds) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiIntervalDS::fseconds"
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct dpiIntervalYM {
    pub years: i32,
    pub months: i32,
}
#[test]
fn bindgen_test_layout_dpiIntervalYM() {
    const UNINIT: ::std::mem::MaybeUninit<dpiIntervalYM> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiIntervalYM>(),
        8usize,
        "Size of dpiIntervalYM"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiIntervalYM>(),
        4usize,
        "Alignment of dpiIntervalYM"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).years) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiIntervalYM::years"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).months) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiIntervalYM::months"
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiJsonNode {
    pub oracleTypeNum: dpiOracleTypeNum,
    pub nativeTypeNum: dpiNativeTypeNum,
    pub value: *mut dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiJsonNode() {
    const UNINIT: ::std::mem::MaybeUninit<dpiJsonNode> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiJsonNode>(),
        16usize,
        "Size of dpiJsonNode"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiJsonNode>(),
        8usize,
        "Alignment of dpiJsonNode"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).oracleTypeNum) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiJsonNode::oracleTypeNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nativeTypeNum) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiJsonNode::nativeTypeNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiJsonNode::value"
    );
}
impl Default for dpiJsonNode {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiJsonObject {
    pub numFields: u32,
    pub fieldNames: *mut *mut ::std::os::raw::c_char,
    pub fieldNameLengths: *mut u32,
    pub fields: *mut dpiJsonNode,
    pub fieldValues: *mut dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiJsonObject() {
    const UNINIT: ::std::mem::MaybeUninit<dpiJsonObject> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiJsonObject>(),
        40usize,
        "Size of dpiJsonObject"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiJsonObject>(),
        8usize,
        "Alignment of dpiJsonObject"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numFields) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiJsonObject::numFields"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fieldNames) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiJsonObject::fieldNames"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fieldNameLengths) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiJsonObject::fieldNameLengths"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fields) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiJsonObject::fields"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fieldValues) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiJsonObject::fieldValues"
    );
}
impl Default for dpiJsonObject {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiJsonArray {
    pub numElements: u32,
    pub elements: *mut dpiJsonNode,
    pub elementValues: *mut dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiJsonArray() {
    const UNINIT: ::std::mem::MaybeUninit<dpiJsonArray> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiJsonArray>(),
        24usize,
        "Size of dpiJsonArray"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiJsonArray>(),
        8usize,
        "Alignment of dpiJsonArray"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numElements) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiJsonArray::numElements"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).elements) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiJsonArray::elements"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).elementValues) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiJsonArray::elementValues"
    );
}
impl Default for dpiJsonArray {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct dpiTimestamp {
    pub year: i16,
    pub month: u8,
    pub day: u8,
    pub hour: u8,
    pub minute: u8,
    pub second: u8,
    pub fsecond: u32,
    pub tzHourOffset: i8,
    pub tzMinuteOffset: i8,
}
#[test]
fn bindgen_test_layout_dpiTimestamp() {
    const UNINIT: ::std::mem::MaybeUninit<dpiTimestamp> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiTimestamp>(),
        16usize,
        "Size of dpiTimestamp"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiTimestamp>(),
        4usize,
        "Alignment of dpiTimestamp"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).year) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiTimestamp::year"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).month) as usize - ptr as usize },
        2usize,
        "Offset of field: dpiTimestamp::month"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).day) as usize - ptr as usize },
        3usize,
        "Offset of field: dpiTimestamp::day"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hour) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiTimestamp::hour"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).minute) as usize - ptr as usize },
        5usize,
        "Offset of field: dpiTimestamp::minute"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize },
        6usize,
        "Offset of field: dpiTimestamp::second"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fsecond) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiTimestamp::fsecond"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tzHourOffset) as usize - ptr as usize },
        12usize,
        "Offset of field: dpiTimestamp::tzHourOffset"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tzMinuteOffset) as usize - ptr as usize },
        13usize,
        "Offset of field: dpiTimestamp::tzMinuteOffset"
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dpiDataBuffer {
    pub asBoolean: ::std::os::raw::c_int,
    pub asUint8: u8,
    pub asUint16: u16,
    pub asUint32: u32,
    pub asInt64: i64,
    pub asUint64: u64,
    pub asFloat: f32,
    pub asDouble: f64,
    pub asString: *mut ::std::os::raw::c_char,
    pub asRaw: *mut ::std::os::raw::c_void,
    pub asBytes: dpiBytes,
    pub asTimestamp: dpiTimestamp,
    pub asIntervalDS: dpiIntervalDS,
    pub asIntervalYM: dpiIntervalYM,
    pub asJson: *mut dpiJson,
    pub asJsonObject: dpiJsonObject,
    pub asJsonArray: dpiJsonArray,
    pub asLOB: *mut dpiLob,
    pub asObject: *mut dpiObject,
    pub asStmt: *mut dpiStmt,
    pub asRowid: *mut dpiRowid,
    pub asVector: *mut dpiVector,
}
#[test]
fn bindgen_test_layout_dpiDataBuffer() {
    const UNINIT: ::std::mem::MaybeUninit<dpiDataBuffer> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiDataBuffer>(),
        40usize,
        "Size of dpiDataBuffer"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiDataBuffer>(),
        8usize,
        "Alignment of dpiDataBuffer"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asBoolean) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asBoolean"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asUint8) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asUint8"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asUint16) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asUint16"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asUint32) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asUint32"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asInt64) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asInt64"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asUint64) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asUint64"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asFloat) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asFloat"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asDouble) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asDouble"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asString) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asString"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asRaw) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asRaw"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asBytes) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asBytes"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asTimestamp) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asTimestamp"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asIntervalDS) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asIntervalDS"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asIntervalYM) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asIntervalYM"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asJson) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asJson"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asJsonObject) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asJsonObject"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asJsonArray) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asJsonArray"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asLOB) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asLOB"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asObject) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asObject"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asStmt) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asStmt"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asRowid) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asRowid"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asVector) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataBuffer::asVector"
    );
}
impl Default for dpiDataBuffer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiAnnotation {
    pub key: *const ::std::os::raw::c_char,
    pub keyLength: u32,
    pub value: *const ::std::os::raw::c_char,
    pub valueLength: u32,
}
#[test]
fn bindgen_test_layout_dpiAnnotation() {
    const UNINIT: ::std::mem::MaybeUninit<dpiAnnotation> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiAnnotation>(),
        32usize,
        "Size of dpiAnnotation"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiAnnotation>(),
        8usize,
        "Alignment of dpiAnnotation"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiAnnotation::key"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).keyLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiAnnotation::keyLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiAnnotation::value"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).valueLength) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiAnnotation::valueLength"
    );
}
impl Default for dpiAnnotation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiAppContext {
    pub namespaceName: *const ::std::os::raw::c_char,
    pub namespaceNameLength: u32,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub value: *const ::std::os::raw::c_char,
    pub valueLength: u32,
}
#[test]
fn bindgen_test_layout_dpiAppContext() {
    const UNINIT: ::std::mem::MaybeUninit<dpiAppContext> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiAppContext>(),
        48usize,
        "Size of dpiAppContext"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiAppContext>(),
        8usize,
        "Alignment of dpiAppContext"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).namespaceName) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiAppContext::namespaceName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).namespaceNameLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiAppContext::namespaceNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiAppContext::name"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiAppContext::nameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiAppContext::value"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).valueLength) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiAppContext::valueLength"
    );
}
impl Default for dpiAppContext {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiCommonCreateParams {
    pub createMode: dpiCreateMode,
    pub encoding: *const ::std::os::raw::c_char,
    pub nencoding: *const ::std::os::raw::c_char,
    pub edition: *const ::std::os::raw::c_char,
    pub editionLength: u32,
    pub driverName: *const ::std::os::raw::c_char,
    pub driverNameLength: u32,
    pub sodaMetadataCache: ::std::os::raw::c_int,
    pub stmtCacheSize: u32,
    pub accessToken: *mut dpiAccessToken,
}
#[test]
fn bindgen_test_layout_dpiCommonCreateParams() {
    const UNINIT: ::std::mem::MaybeUninit<dpiCommonCreateParams> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiCommonCreateParams>(),
        72usize,
        "Size of dpiCommonCreateParams"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiCommonCreateParams>(),
        8usize,
        "Alignment of dpiCommonCreateParams"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).createMode) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiCommonCreateParams::createMode"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiCommonCreateParams::encoding"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nencoding) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiCommonCreateParams::nencoding"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).edition) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiCommonCreateParams::edition"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).editionLength) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiCommonCreateParams::editionLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).driverName) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiCommonCreateParams::driverName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).driverNameLength) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiCommonCreateParams::driverNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sodaMetadataCache) as usize - ptr as usize },
        52usize,
        "Offset of field: dpiCommonCreateParams::sodaMetadataCache"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stmtCacheSize) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiCommonCreateParams::stmtCacheSize"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accessToken) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiCommonCreateParams::accessToken"
    );
}
impl Default for dpiCommonCreateParams {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiConnCreateParams {
    pub authMode: dpiAuthMode,
    pub connectionClass: *const ::std::os::raw::c_char,
    pub connectionClassLength: u32,
    pub purity: dpiPurity,
    pub newPassword: *const ::std::os::raw::c_char,
    pub newPasswordLength: u32,
    pub appContext: *mut dpiAppContext,
    pub numAppContext: u32,
    pub externalAuth: ::std::os::raw::c_int,
    pub externalHandle: *mut ::std::os::raw::c_void,
    pub pool: *mut dpiPool,
    pub tag: *const ::std::os::raw::c_char,
    pub tagLength: u32,
    pub matchAnyTag: ::std::os::raw::c_int,
    pub outTag: *const ::std::os::raw::c_char,
    pub outTagLength: u32,
    pub outTagFound: ::std::os::raw::c_int,
    pub shardingKeyColumns: *mut dpiShardingKeyColumn,
    pub numShardingKeyColumns: u8,
    pub superShardingKeyColumns: *mut dpiShardingKeyColumn,
    pub numSuperShardingKeyColumns: u8,
    pub outNewSession: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiConnCreateParams() {
    const UNINIT: ::std::mem::MaybeUninit<dpiConnCreateParams> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiConnCreateParams>(),
        136usize,
        "Size of dpiConnCreateParams"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiConnCreateParams>(),
        8usize,
        "Alignment of dpiConnCreateParams"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).authMode) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiConnCreateParams::authMode"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).connectionClass) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiConnCreateParams::connectionClass"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).connectionClassLength) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiConnCreateParams::connectionClassLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).purity) as usize - ptr as usize },
        20usize,
        "Offset of field: dpiConnCreateParams::purity"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).newPassword) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiConnCreateParams::newPassword"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).newPasswordLength) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiConnCreateParams::newPasswordLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).appContext) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiConnCreateParams::appContext"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numAppContext) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiConnCreateParams::numAppContext"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).externalAuth) as usize - ptr as usize },
        52usize,
        "Offset of field: dpiConnCreateParams::externalAuth"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).externalHandle) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiConnCreateParams::externalHandle"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiConnCreateParams::pool"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tag) as usize - ptr as usize },
        72usize,
        "Offset of field: dpiConnCreateParams::tag"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tagLength) as usize - ptr as usize },
        80usize,
        "Offset of field: dpiConnCreateParams::tagLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).matchAnyTag) as usize - ptr as usize },
        84usize,
        "Offset of field: dpiConnCreateParams::matchAnyTag"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outTag) as usize - ptr as usize },
        88usize,
        "Offset of field: dpiConnCreateParams::outTag"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outTagLength) as usize - ptr as usize },
        96usize,
        "Offset of field: dpiConnCreateParams::outTagLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outTagFound) as usize - ptr as usize },
        100usize,
        "Offset of field: dpiConnCreateParams::outTagFound"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).shardingKeyColumns) as usize - ptr as usize },
        104usize,
        "Offset of field: dpiConnCreateParams::shardingKeyColumns"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numShardingKeyColumns) as usize - ptr as usize },
        112usize,
        "Offset of field: dpiConnCreateParams::numShardingKeyColumns"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).superShardingKeyColumns) as usize - ptr as usize },
        120usize,
        "Offset of field: dpiConnCreateParams::superShardingKeyColumns"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numSuperShardingKeyColumns) as usize - ptr as usize },
        128usize,
        "Offset of field: dpiConnCreateParams::numSuperShardingKeyColumns"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outNewSession) as usize - ptr as usize },
        132usize,
        "Offset of field: dpiConnCreateParams::outNewSession"
    );
}
impl Default for dpiConnCreateParams {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiConnInfo {
    pub dbDomain: *const ::std::os::raw::c_char,
    pub dbDomainLength: u32,
    pub dbName: *const ::std::os::raw::c_char,
    pub dbNameLength: u32,
    pub instanceName: *const ::std::os::raw::c_char,
    pub instanceNameLength: u32,
    pub serviceName: *const ::std::os::raw::c_char,
    pub serviceNameLength: u32,
    pub maxIdentifierLength: u32,
    pub maxOpenCursors: u32,
    pub serverType: u8,
}
#[test]
fn bindgen_test_layout_dpiConnInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiConnInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiConnInfo>(),
        72usize,
        "Size of dpiConnInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiConnInfo>(),
        8usize,
        "Alignment of dpiConnInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dbDomain) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiConnInfo::dbDomain"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dbDomainLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiConnInfo::dbDomainLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dbName) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiConnInfo::dbName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dbNameLength) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiConnInfo::dbNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).instanceName) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiConnInfo::instanceName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).instanceNameLength) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiConnInfo::instanceNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).serviceName) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiConnInfo::serviceName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).serviceNameLength) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiConnInfo::serviceNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxIdentifierLength) as usize - ptr as usize },
        60usize,
        "Offset of field: dpiConnInfo::maxIdentifierLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxOpenCursors) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiConnInfo::maxOpenCursors"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).serverType) as usize - ptr as usize },
        68usize,
        "Offset of field: dpiConnInfo::serverType"
    );
}
impl Default for dpiConnInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiContextCreateParams {
    pub defaultDriverName: *const ::std::os::raw::c_char,
    pub defaultEncoding: *const ::std::os::raw::c_char,
    pub loadErrorUrl: *const ::std::os::raw::c_char,
    pub oracleClientLibDir: *const ::std::os::raw::c_char,
    pub oracleClientConfigDir: *const ::std::os::raw::c_char,
    pub sodaUseJsonDesc: ::std::os::raw::c_int,
    pub useJsonId: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiContextCreateParams() {
    const UNINIT: ::std::mem::MaybeUninit<dpiContextCreateParams> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiContextCreateParams>(),
        48usize,
        "Size of dpiContextCreateParams"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiContextCreateParams>(),
        8usize,
        "Alignment of dpiContextCreateParams"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaultDriverName) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiContextCreateParams::defaultDriverName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaultEncoding) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiContextCreateParams::defaultEncoding"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).loadErrorUrl) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiContextCreateParams::loadErrorUrl"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).oracleClientLibDir) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiContextCreateParams::oracleClientLibDir"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).oracleClientConfigDir) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiContextCreateParams::oracleClientConfigDir"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sodaUseJsonDesc) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiContextCreateParams::sodaUseJsonDesc"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).useJsonId) as usize - ptr as usize },
        44usize,
        "Offset of field: dpiContextCreateParams::useJsonId"
    );
}
impl Default for dpiContextCreateParams {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dpiData {
    pub isNull: ::std::os::raw::c_int,
    pub value: dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiData() {
    const UNINIT: ::std::mem::MaybeUninit<dpiData> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(::std::mem::size_of::<dpiData>(), 48usize, "Size of dpiData");
    assert_eq!(
        ::std::mem::align_of::<dpiData>(),
        8usize,
        "Alignment of dpiData"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isNull) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiData::isNull"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiData::value"
    );
}
impl Default for dpiData {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiDataTypeInfo {
    pub oracleTypeNum: dpiOracleTypeNum,
    pub defaultNativeTypeNum: dpiNativeTypeNum,
    pub ociTypeCode: u16,
    pub dbSizeInBytes: u32,
    pub clientSizeInBytes: u32,
    pub sizeInChars: u32,
    pub precision: i16,
    pub scale: i8,
    pub fsPrecision: u8,
    pub objectType: *mut dpiObjectType,
    pub isJson: ::std::os::raw::c_int,
    pub domainSchema: *const ::std::os::raw::c_char,
    pub domainSchemaLength: u32,
    pub domainName: *const ::std::os::raw::c_char,
    pub domainNameLength: u32,
    pub numAnnotations: u32,
    pub annotations: *mut dpiAnnotation,
    pub isOson: ::std::os::raw::c_int,
    pub vectorDimensions: u32,
    pub vectorFormat: u8,
    pub vectorFlags: u8,
}
#[test]
fn bindgen_test_layout_dpiDataTypeInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiDataTypeInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiDataTypeInfo>(),
        104usize,
        "Size of dpiDataTypeInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiDataTypeInfo>(),
        8usize,
        "Alignment of dpiDataTypeInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).oracleTypeNum) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiDataTypeInfo::oracleTypeNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaultNativeTypeNum) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiDataTypeInfo::defaultNativeTypeNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ociTypeCode) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiDataTypeInfo::ociTypeCode"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dbSizeInBytes) as usize - ptr as usize },
        12usize,
        "Offset of field: dpiDataTypeInfo::dbSizeInBytes"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clientSizeInBytes) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiDataTypeInfo::clientSizeInBytes"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sizeInChars) as usize - ptr as usize },
        20usize,
        "Offset of field: dpiDataTypeInfo::sizeInChars"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).precision) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiDataTypeInfo::precision"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
        26usize,
        "Offset of field: dpiDataTypeInfo::scale"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fsPrecision) as usize - ptr as usize },
        27usize,
        "Offset of field: dpiDataTypeInfo::fsPrecision"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).objectType) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiDataTypeInfo::objectType"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isJson) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiDataTypeInfo::isJson"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).domainSchema) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiDataTypeInfo::domainSchema"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).domainSchemaLength) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiDataTypeInfo::domainSchemaLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).domainName) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiDataTypeInfo::domainName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).domainNameLength) as usize - ptr as usize },
        72usize,
        "Offset of field: dpiDataTypeInfo::domainNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numAnnotations) as usize - ptr as usize },
        76usize,
        "Offset of field: dpiDataTypeInfo::numAnnotations"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).annotations) as usize - ptr as usize },
        80usize,
        "Offset of field: dpiDataTypeInfo::annotations"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isOson) as usize - ptr as usize },
        88usize,
        "Offset of field: dpiDataTypeInfo::isOson"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vectorDimensions) as usize - ptr as usize },
        92usize,
        "Offset of field: dpiDataTypeInfo::vectorDimensions"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vectorFormat) as usize - ptr as usize },
        96usize,
        "Offset of field: dpiDataTypeInfo::vectorFormat"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vectorFlags) as usize - ptr as usize },
        97usize,
        "Offset of field: dpiDataTypeInfo::vectorFlags"
    );
}
impl Default for dpiDataTypeInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiAccessToken {
    pub token: *const ::std::os::raw::c_char,
    pub tokenLength: u32,
    pub privateKey: *const ::std::os::raw::c_char,
    pub privateKeyLength: u32,
}
#[test]
fn bindgen_test_layout_dpiAccessToken() {
    const UNINIT: ::std::mem::MaybeUninit<dpiAccessToken> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiAccessToken>(),
        32usize,
        "Size of dpiAccessToken"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiAccessToken>(),
        8usize,
        "Alignment of dpiAccessToken"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiAccessToken::token"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tokenLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiAccessToken::tokenLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).privateKey) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiAccessToken::privateKey"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).privateKeyLength) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiAccessToken::privateKeyLength"
    );
}
impl Default for dpiAccessToken {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiEncodingInfo {
    pub encoding: *const ::std::os::raw::c_char,
    pub maxBytesPerCharacter: i32,
    pub nencoding: *const ::std::os::raw::c_char,
    pub nmaxBytesPerCharacter: i32,
}
#[test]
fn bindgen_test_layout_dpiEncodingInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiEncodingInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiEncodingInfo>(),
        32usize,
        "Size of dpiEncodingInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiEncodingInfo>(),
        8usize,
        "Alignment of dpiEncodingInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiEncodingInfo::encoding"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxBytesPerCharacter) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiEncodingInfo::maxBytesPerCharacter"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nencoding) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiEncodingInfo::nencoding"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nmaxBytesPerCharacter) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiEncodingInfo::nmaxBytesPerCharacter"
    );
}
impl Default for dpiEncodingInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiErrorInfo {
    pub code: i32,
    pub offset16: u16,
    pub message: *const ::std::os::raw::c_char,
    pub messageLength: u32,
    pub encoding: *const ::std::os::raw::c_char,
    pub fnName: *const ::std::os::raw::c_char,
    pub action: *const ::std::os::raw::c_char,
    pub sqlState: *const ::std::os::raw::c_char,
    pub isRecoverable: ::std::os::raw::c_int,
    pub isWarning: ::std::os::raw::c_int,
    pub offset: u32,
}
#[test]
fn bindgen_test_layout_dpiErrorInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiErrorInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiErrorInfo>(),
        72usize,
        "Size of dpiErrorInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiErrorInfo>(),
        8usize,
        "Alignment of dpiErrorInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiErrorInfo::code"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset16) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiErrorInfo::offset16"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiErrorInfo::message"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).messageLength) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiErrorInfo::messageLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiErrorInfo::encoding"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fnName) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiErrorInfo::fnName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiErrorInfo::action"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sqlState) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiErrorInfo::sqlState"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isRecoverable) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiErrorInfo::isRecoverable"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isWarning) as usize - ptr as usize },
        60usize,
        "Offset of field: dpiErrorInfo::isWarning"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiErrorInfo::offset"
    );
}
impl Default for dpiErrorInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObjectAttrInfo {
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub typeInfo: dpiDataTypeInfo,
}
#[test]
fn bindgen_test_layout_dpiObjectAttrInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiObjectAttrInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiObjectAttrInfo>(),
        120usize,
        "Size of dpiObjectAttrInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiObjectAttrInfo>(),
        8usize,
        "Alignment of dpiObjectAttrInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiObjectAttrInfo::name"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiObjectAttrInfo::nameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).typeInfo) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiObjectAttrInfo::typeInfo"
    );
}
impl Default for dpiObjectAttrInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObjectTypeInfo {
    pub schema: *const ::std::os::raw::c_char,
    pub schemaLength: u32,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub isCollection: ::std::os::raw::c_int,
    pub elementTypeInfo: dpiDataTypeInfo,
    pub numAttributes: u16,
    pub packageName: *const ::std::os::raw::c_char,
    pub packageNameLength: u32,
}
#[test]
fn bindgen_test_layout_dpiObjectTypeInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiObjectTypeInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiObjectTypeInfo>(),
        160usize,
        "Size of dpiObjectTypeInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiObjectTypeInfo>(),
        8usize,
        "Alignment of dpiObjectTypeInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).schema) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiObjectTypeInfo::schema"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).schemaLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiObjectTypeInfo::schemaLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiObjectTypeInfo::name"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiObjectTypeInfo::nameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isCollection) as usize - ptr as usize },
        28usize,
        "Offset of field: dpiObjectTypeInfo::isCollection"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).elementTypeInfo) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiObjectTypeInfo::elementTypeInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numAttributes) as usize - ptr as usize },
        136usize,
        "Offset of field: dpiObjectTypeInfo::numAttributes"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).packageName) as usize - ptr as usize },
        144usize,
        "Offset of field: dpiObjectTypeInfo::packageName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).packageNameLength) as usize - ptr as usize },
        152usize,
        "Offset of field: dpiObjectTypeInfo::packageNameLength"
    );
}
impl Default for dpiObjectTypeInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiPoolCreateParams {
    pub minSessions: u32,
    pub maxSessions: u32,
    pub sessionIncrement: u32,
    pub pingInterval: ::std::os::raw::c_int,
    pub pingTimeout: ::std::os::raw::c_int,
    pub homogeneous: ::std::os::raw::c_int,
    pub externalAuth: ::std::os::raw::c_int,
    pub getMode: dpiPoolGetMode,
    pub outPoolName: *const ::std::os::raw::c_char,
    pub outPoolNameLength: u32,
    pub timeout: u32,
    pub waitTimeout: u32,
    pub maxLifetimeSession: u32,
    pub plsqlFixupCallback: *const ::std::os::raw::c_char,
    pub plsqlFixupCallbackLength: u32,
    pub maxSessionsPerShard: u32,
    pub accessTokenCallback: dpiAccessTokenCallback,
    pub accessTokenCallbackContext: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_dpiPoolCreateParams() {
    const UNINIT: ::std::mem::MaybeUninit<dpiPoolCreateParams> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiPoolCreateParams>(),
        88usize,
        "Size of dpiPoolCreateParams"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiPoolCreateParams>(),
        8usize,
        "Alignment of dpiPoolCreateParams"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).minSessions) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiPoolCreateParams::minSessions"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxSessions) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiPoolCreateParams::maxSessions"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sessionIncrement) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiPoolCreateParams::sessionIncrement"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pingInterval) as usize - ptr as usize },
        12usize,
        "Offset of field: dpiPoolCreateParams::pingInterval"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pingTimeout) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiPoolCreateParams::pingTimeout"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).homogeneous) as usize - ptr as usize },
        20usize,
        "Offset of field: dpiPoolCreateParams::homogeneous"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).externalAuth) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiPoolCreateParams::externalAuth"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).getMode) as usize - ptr as usize },
        28usize,
        "Offset of field: dpiPoolCreateParams::getMode"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outPoolName) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiPoolCreateParams::outPoolName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outPoolNameLength) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiPoolCreateParams::outPoolNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
        44usize,
        "Offset of field: dpiPoolCreateParams::timeout"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).waitTimeout) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiPoolCreateParams::waitTimeout"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxLifetimeSession) as usize - ptr as usize },
        52usize,
        "Offset of field: dpiPoolCreateParams::maxLifetimeSession"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).plsqlFixupCallback) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiPoolCreateParams::plsqlFixupCallback"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).plsqlFixupCallbackLength) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiPoolCreateParams::plsqlFixupCallbackLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxSessionsPerShard) as usize - ptr as usize },
        68usize,
        "Offset of field: dpiPoolCreateParams::maxSessionsPerShard"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accessTokenCallback) as usize - ptr as usize },
        72usize,
        "Offset of field: dpiPoolCreateParams::accessTokenCallback"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accessTokenCallbackContext) as usize - ptr as usize },
        80usize,
        "Offset of field: dpiPoolCreateParams::accessTokenCallbackContext"
    );
}
impl Default for dpiPoolCreateParams {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiQueryInfo {
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub typeInfo: dpiDataTypeInfo,
    pub nullOk: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiQueryInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiQueryInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiQueryInfo>(),
        128usize,
        "Size of dpiQueryInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiQueryInfo>(),
        8usize,
        "Alignment of dpiQueryInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiQueryInfo::name"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiQueryInfo::nameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).typeInfo) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiQueryInfo::typeInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nullOk) as usize - ptr as usize },
        120usize,
        "Offset of field: dpiQueryInfo::nullOk"
    );
}
impl Default for dpiQueryInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiMsgRecipient {
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
}
#[test]
fn bindgen_test_layout_dpiMsgRecipient() {
    const UNINIT: ::std::mem::MaybeUninit<dpiMsgRecipient> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiMsgRecipient>(),
        16usize,
        "Size of dpiMsgRecipient"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiMsgRecipient>(),
        8usize,
        "Alignment of dpiMsgRecipient"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiMsgRecipient::name"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiMsgRecipient::nameLength"
    );
}
impl Default for dpiMsgRecipient {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dpiShardingKeyColumn {
    pub oracleTypeNum: dpiOracleTypeNum,
    pub nativeTypeNum: dpiNativeTypeNum,
    pub value: dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiShardingKeyColumn() {
    const UNINIT: ::std::mem::MaybeUninit<dpiShardingKeyColumn> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiShardingKeyColumn>(),
        48usize,
        "Size of dpiShardingKeyColumn"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiShardingKeyColumn>(),
        8usize,
        "Alignment of dpiShardingKeyColumn"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).oracleTypeNum) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiShardingKeyColumn::oracleTypeNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nativeTypeNum) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiShardingKeyColumn::nativeTypeNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiShardingKeyColumn::value"
    );
}
impl Default for dpiShardingKeyColumn {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dpiStringList {
    pub __bindgen_anon_1: dpiStringList__bindgen_ty_1,
    pub __bindgen_anon_2: dpiStringList__bindgen_ty_2,
    pub __bindgen_anon_3: dpiStringList__bindgen_ty_3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dpiStringList__bindgen_ty_1 {
    pub numStrings: u32,
    pub numNames: u32,
}
#[test]
fn bindgen_test_layout_dpiStringList__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<dpiStringList__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiStringList__bindgen_ty_1>(),
        4usize,
        "Size of dpiStringList__bindgen_ty_1"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiStringList__bindgen_ty_1>(),
        4usize,
        "Alignment of dpiStringList__bindgen_ty_1"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numStrings) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiStringList__bindgen_ty_1::numStrings"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numNames) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiStringList__bindgen_ty_1::numNames"
    );
}
impl Default for dpiStringList__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dpiStringList__bindgen_ty_2 {
    pub strings: *mut *const ::std::os::raw::c_char,
    pub names: *mut *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dpiStringList__bindgen_ty_2() {
    const UNINIT: ::std::mem::MaybeUninit<dpiStringList__bindgen_ty_2> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiStringList__bindgen_ty_2>(),
        8usize,
        "Size of dpiStringList__bindgen_ty_2"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiStringList__bindgen_ty_2>(),
        8usize,
        "Alignment of dpiStringList__bindgen_ty_2"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).strings) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiStringList__bindgen_ty_2::strings"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiStringList__bindgen_ty_2::names"
    );
}
impl Default for dpiStringList__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dpiStringList__bindgen_ty_3 {
    pub stringLengths: *mut u32,
    pub nameLengths: *mut u32,
}
#[test]
fn bindgen_test_layout_dpiStringList__bindgen_ty_3() {
    const UNINIT: ::std::mem::MaybeUninit<dpiStringList__bindgen_ty_3> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiStringList__bindgen_ty_3>(),
        8usize,
        "Size of dpiStringList__bindgen_ty_3"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiStringList__bindgen_ty_3>(),
        8usize,
        "Alignment of dpiStringList__bindgen_ty_3"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stringLengths) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiStringList__bindgen_ty_3::stringLengths"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLengths) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiStringList__bindgen_ty_3::nameLengths"
    );
}
impl Default for dpiStringList__bindgen_ty_3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_dpiStringList() {
    assert_eq!(
        ::std::mem::size_of::<dpiStringList>(),
        24usize,
        "Size of dpiStringList"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiStringList>(),
        8usize,
        "Alignment of dpiStringList"
    );
}
impl Default for dpiStringList {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaOperOptions {
    pub numKeys: u32,
    pub keys: *mut *const ::std::os::raw::c_char,
    pub keyLengths: *mut u32,
    pub key: *const ::std::os::raw::c_char,
    pub keyLength: u32,
    pub version: *const ::std::os::raw::c_char,
    pub versionLength: u32,
    pub filter: *const ::std::os::raw::c_char,
    pub filterLength: u32,
    pub skip: u32,
    pub limit: u32,
    pub fetchArraySize: u32,
    pub hint: *const ::std::os::raw::c_char,
    pub hintLength: u32,
    pub lock: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiSodaOperOptions() {
    const UNINIT: ::std::mem::MaybeUninit<dpiSodaOperOptions> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiSodaOperOptions>(),
        96usize,
        "Size of dpiSodaOperOptions"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSodaOperOptions>(),
        8usize,
        "Alignment of dpiSodaOperOptions"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numKeys) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiSodaOperOptions::numKeys"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).keys) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiSodaOperOptions::keys"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).keyLengths) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiSodaOperOptions::keyLengths"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiSodaOperOptions::key"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).keyLength) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiSodaOperOptions::keyLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiSodaOperOptions::version"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).versionLength) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiSodaOperOptions::versionLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).filter) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiSodaOperOptions::filter"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).filterLength) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiSodaOperOptions::filterLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).skip) as usize - ptr as usize },
        68usize,
        "Offset of field: dpiSodaOperOptions::skip"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize },
        72usize,
        "Offset of field: dpiSodaOperOptions::limit"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fetchArraySize) as usize - ptr as usize },
        76usize,
        "Offset of field: dpiSodaOperOptions::fetchArraySize"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hint) as usize - ptr as usize },
        80usize,
        "Offset of field: dpiSodaOperOptions::hint"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hintLength) as usize - ptr as usize },
        88usize,
        "Offset of field: dpiSodaOperOptions::hintLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lock) as usize - ptr as usize },
        92usize,
        "Offset of field: dpiSodaOperOptions::lock"
    );
}
impl Default for dpiSodaOperOptions {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct dpiStmtInfo {
    pub isQuery: ::std::os::raw::c_int,
    pub isPLSQL: ::std::os::raw::c_int,
    pub isDDL: ::std::os::raw::c_int,
    pub isDML: ::std::os::raw::c_int,
    pub statementType: dpiStatementType,
    pub isReturning: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiStmtInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiStmtInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiStmtInfo>(),
        24usize,
        "Size of dpiStmtInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiStmtInfo>(),
        4usize,
        "Alignment of dpiStmtInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isQuery) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiStmtInfo::isQuery"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isPLSQL) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiStmtInfo::isPLSQL"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isDDL) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiStmtInfo::isDDL"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isDML) as usize - ptr as usize },
        12usize,
        "Offset of field: dpiStmtInfo::isDML"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).statementType) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiStmtInfo::statementType"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).isReturning) as usize - ptr as usize },
        20usize,
        "Offset of field: dpiStmtInfo::isReturning"
    );
}
pub type dpiSubscrCallback = ::std::option::Option<
    unsafe extern "C" fn(context: *mut ::std::os::raw::c_void, message: *mut dpiSubscrMessage),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscrCreateParams {
    pub subscrNamespace: dpiSubscrNamespace,
    pub protocol: dpiSubscrProtocol,
    pub qos: dpiSubscrQOS,
    pub operations: dpiOpCode,
    pub portNumber: u32,
    pub timeout: u32,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub callback: dpiSubscrCallback,
    pub callbackContext: *mut ::std::os::raw::c_void,
    pub recipientName: *const ::std::os::raw::c_char,
    pub recipientNameLength: u32,
    pub ipAddress: *const ::std::os::raw::c_char,
    pub ipAddressLength: u32,
    pub groupingClass: u8,
    pub groupingValue: u32,
    pub groupingType: u8,
    pub outRegId: u64,
    pub clientInitiated: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiSubscrCreateParams() {
    const UNINIT: ::std::mem::MaybeUninit<dpiSubscrCreateParams> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrCreateParams>(),
        112usize,
        "Size of dpiSubscrCreateParams"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrCreateParams>(),
        8usize,
        "Alignment of dpiSubscrCreateParams"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).subscrNamespace) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiSubscrCreateParams::subscrNamespace"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).protocol) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiSubscrCreateParams::protocol"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiSubscrCreateParams::qos"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).operations) as usize - ptr as usize },
        12usize,
        "Offset of field: dpiSubscrCreateParams::operations"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).portNumber) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiSubscrCreateParams::portNumber"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
        20usize,
        "Offset of field: dpiSubscrCreateParams::timeout"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiSubscrCreateParams::name"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiSubscrCreateParams::nameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiSubscrCreateParams::callback"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).callbackContext) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiSubscrCreateParams::callbackContext"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).recipientName) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiSubscrCreateParams::recipientName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).recipientNameLength) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiSubscrCreateParams::recipientNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ipAddress) as usize - ptr as usize },
        72usize,
        "Offset of field: dpiSubscrCreateParams::ipAddress"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ipAddressLength) as usize - ptr as usize },
        80usize,
        "Offset of field: dpiSubscrCreateParams::ipAddressLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).groupingClass) as usize - ptr as usize },
        84usize,
        "Offset of field: dpiSubscrCreateParams::groupingClass"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).groupingValue) as usize - ptr as usize },
        88usize,
        "Offset of field: dpiSubscrCreateParams::groupingValue"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).groupingType) as usize - ptr as usize },
        92usize,
        "Offset of field: dpiSubscrCreateParams::groupingType"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outRegId) as usize - ptr as usize },
        96usize,
        "Offset of field: dpiSubscrCreateParams::outRegId"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clientInitiated) as usize - ptr as usize },
        104usize,
        "Offset of field: dpiSubscrCreateParams::clientInitiated"
    );
}
impl Default for dpiSubscrCreateParams {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscrMessage {
    pub eventType: dpiEventType,
    pub dbName: *const ::std::os::raw::c_char,
    pub dbNameLength: u32,
    pub tables: *mut dpiSubscrMessageTable,
    pub numTables: u32,
    pub queries: *mut dpiSubscrMessageQuery,
    pub numQueries: u32,
    pub errorInfo: *mut dpiErrorInfo,
    pub txId: *const ::std::os::raw::c_void,
    pub txIdLength: u32,
    pub registered: ::std::os::raw::c_int,
    pub queueName: *const ::std::os::raw::c_char,
    pub queueNameLength: u32,
    pub consumerName: *const ::std::os::raw::c_char,
    pub consumerNameLength: u32,
    pub aqMsgId: *const ::std::os::raw::c_void,
    pub aqMsgIdLength: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessage() {
    const UNINIT: ::std::mem::MaybeUninit<dpiSubscrMessage> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessage>(),
        128usize,
        "Size of dpiSubscrMessage"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessage>(),
        8usize,
        "Alignment of dpiSubscrMessage"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eventType) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiSubscrMessage::eventType"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dbName) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiSubscrMessage::dbName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dbNameLength) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiSubscrMessage::dbNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tables) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiSubscrMessage::tables"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numTables) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiSubscrMessage::numTables"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).queries) as usize - ptr as usize },
        40usize,
        "Offset of field: dpiSubscrMessage::queries"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numQueries) as usize - ptr as usize },
        48usize,
        "Offset of field: dpiSubscrMessage::numQueries"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).errorInfo) as usize - ptr as usize },
        56usize,
        "Offset of field: dpiSubscrMessage::errorInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).txId) as usize - ptr as usize },
        64usize,
        "Offset of field: dpiSubscrMessage::txId"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).txIdLength) as usize - ptr as usize },
        72usize,
        "Offset of field: dpiSubscrMessage::txIdLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).registered) as usize - ptr as usize },
        76usize,
        "Offset of field: dpiSubscrMessage::registered"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).queueName) as usize - ptr as usize },
        80usize,
        "Offset of field: dpiSubscrMessage::queueName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).queueNameLength) as usize - ptr as usize },
        88usize,
        "Offset of field: dpiSubscrMessage::queueNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).consumerName) as usize - ptr as usize },
        96usize,
        "Offset of field: dpiSubscrMessage::consumerName"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).consumerNameLength) as usize - ptr as usize },
        104usize,
        "Offset of field: dpiSubscrMessage::consumerNameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).aqMsgId) as usize - ptr as usize },
        112usize,
        "Offset of field: dpiSubscrMessage::aqMsgId"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).aqMsgIdLength) as usize - ptr as usize },
        120usize,
        "Offset of field: dpiSubscrMessage::aqMsgIdLength"
    );
}
impl Default for dpiSubscrMessage {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscrMessageQuery {
    pub id: u64,
    pub operation: dpiOpCode,
    pub tables: *mut dpiSubscrMessageTable,
    pub numTables: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessageQuery() {
    const UNINIT: ::std::mem::MaybeUninit<dpiSubscrMessageQuery> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessageQuery>(),
        32usize,
        "Size of dpiSubscrMessageQuery"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessageQuery>(),
        8usize,
        "Alignment of dpiSubscrMessageQuery"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiSubscrMessageQuery::id"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiSubscrMessageQuery::operation"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tables) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiSubscrMessageQuery::tables"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numTables) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiSubscrMessageQuery::numTables"
    );
}
impl Default for dpiSubscrMessageQuery {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscrMessageRow {
    pub operation: dpiOpCode,
    pub rowid: *const ::std::os::raw::c_char,
    pub rowidLength: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessageRow() {
    const UNINIT: ::std::mem::MaybeUninit<dpiSubscrMessageRow> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessageRow>(),
        24usize,
        "Size of dpiSubscrMessageRow"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessageRow>(),
        8usize,
        "Alignment of dpiSubscrMessageRow"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiSubscrMessageRow::operation"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rowid) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiSubscrMessageRow::rowid"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rowidLength) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiSubscrMessageRow::rowidLength"
    );
}
impl Default for dpiSubscrMessageRow {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscrMessageTable {
    pub operation: dpiOpCode,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub rows: *mut dpiSubscrMessageRow,
    pub numRows: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessageTable() {
    const UNINIT: ::std::mem::MaybeUninit<dpiSubscrMessageTable> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessageTable>(),
        40usize,
        "Size of dpiSubscrMessageTable"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessageTable>(),
        8usize,
        "Alignment of dpiSubscrMessageTable"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiSubscrMessageTable::operation"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiSubscrMessageTable::name"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiSubscrMessageTable::nameLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rows) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiSubscrMessageTable::rows"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numRows) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiSubscrMessageTable::numRows"
    );
}
impl Default for dpiSubscrMessageTable {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct dpiVersionInfo {
    pub versionNum: ::std::os::raw::c_int,
    pub releaseNum: ::std::os::raw::c_int,
    pub updateNum: ::std::os::raw::c_int,
    pub portReleaseNum: ::std::os::raw::c_int,
    pub portUpdateNum: ::std::os::raw::c_int,
    pub fullVersionNum: u32,
}
#[test]
fn bindgen_test_layout_dpiVersionInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiVersionInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiVersionInfo>(),
        24usize,
        "Size of dpiVersionInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiVersionInfo>(),
        4usize,
        "Alignment of dpiVersionInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).versionNum) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiVersionInfo::versionNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).releaseNum) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiVersionInfo::releaseNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).updateNum) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiVersionInfo::updateNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).portReleaseNum) as usize - ptr as usize },
        12usize,
        "Offset of field: dpiVersionInfo::portReleaseNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).portUpdateNum) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiVersionInfo::portUpdateNum"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fullVersionNum) as usize - ptr as usize },
        20usize,
        "Offset of field: dpiVersionInfo::fullVersionNum"
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dpiVectorDimensionBuffer {
    pub asPtr: *mut ::std::os::raw::c_void,
    pub asInt8: *mut i8,
    pub asFloat: *mut f32,
    pub asDouble: *mut f64,
}
#[test]
fn bindgen_test_layout_dpiVectorDimensionBuffer() {
    const UNINIT: ::std::mem::MaybeUninit<dpiVectorDimensionBuffer> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiVectorDimensionBuffer>(),
        8usize,
        "Size of dpiVectorDimensionBuffer"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiVectorDimensionBuffer>(),
        8usize,
        "Alignment of dpiVectorDimensionBuffer"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asPtr) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiVectorDimensionBuffer::asPtr"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asInt8) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiVectorDimensionBuffer::asInt8"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asFloat) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiVectorDimensionBuffer::asFloat"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asDouble) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiVectorDimensionBuffer::asDouble"
    );
}
impl Default for dpiVectorDimensionBuffer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dpiVectorInfo {
    pub format: u8,
    pub numDimensions: u32,
    pub dimensionSize: u8,
    pub dimensions: dpiVectorDimensionBuffer,
}
#[test]
fn bindgen_test_layout_dpiVectorInfo() {
    const UNINIT: ::std::mem::MaybeUninit<dpiVectorInfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dpiVectorInfo>(),
        24usize,
        "Size of dpiVectorInfo"
    );
    assert_eq!(
        ::std::mem::align_of::<dpiVectorInfo>(),
        8usize,
        "Alignment of dpiVectorInfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiVectorInfo::format"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numDimensions) as usize - ptr as usize },
        4usize,
        "Offset of field: dpiVectorInfo::numDimensions"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dimensionSize) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiVectorInfo::dimensionSize"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dimensions) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiVectorInfo::dimensions"
    );
}
impl Default for dpiVectorInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiXid {
    pub formatId: ::std::os::raw::c_long,
    pub globalTransactionId: *const ::std::os::raw::c_char,
    pub globalTransactionIdLength: u32,
    pub branchQualifier: *const ::std::os::raw::c_char,
    pub branchQualifierLength: u32,
}
#[test]
fn bindgen_test_layout_dpiXid() {
    const UNINIT: ::std::mem::MaybeUninit<dpiXid> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(::std::mem::size_of::<dpiXid>(), 40usize, "Size of dpiXid");
    assert_eq!(
        ::std::mem::align_of::<dpiXid>(),
        8usize,
        "Alignment of dpiXid"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).formatId) as usize - ptr as usize },
        0usize,
        "Offset of field: dpiXid::formatId"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).globalTransactionId) as usize - ptr as usize },
        8usize,
        "Offset of field: dpiXid::globalTransactionId"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).globalTransactionIdLength) as usize - ptr as usize },
        16usize,
        "Offset of field: dpiXid::globalTransactionIdLength"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).branchQualifier) as usize - ptr as usize },
        24usize,
        "Offset of field: dpiXid::branchQualifier"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).branchQualifierLength) as usize - ptr as usize },
        32usize,
        "Offset of field: dpiXid::branchQualifierLength"
    );
}
impl Default for dpiXid {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
extern "C" {
    pub fn dpiContext_createWithParams(
        majorVersion: ::std::os::raw::c_uint,
        minorVersion: ::std::os::raw::c_uint,
        params: *mut dpiContextCreateParams,
        context: *mut *mut dpiContext,
        errorInfo: *mut dpiErrorInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_destroy(context: *mut dpiContext) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_freeStringList(
        context: *mut dpiContext,
        list: *mut dpiStringList,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_getClientVersion(
        context: *const dpiContext,
        versionInfo: *mut dpiVersionInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_getError(context: *const dpiContext, errorInfo: *mut dpiErrorInfo);
}
extern "C" {
    pub fn dpiContext_initCommonCreateParams(
        context: *const dpiContext,
        params: *mut dpiCommonCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initConnCreateParams(
        context: *const dpiContext,
        params: *mut dpiConnCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initPoolCreateParams(
        context: *const dpiContext,
        params: *mut dpiPoolCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initSodaOperOptions(
        context: *const dpiContext,
        options: *mut dpiSodaOperOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initSubscrCreateParams(
        context: *const dpiContext,
        params: *mut dpiSubscrCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_addRef(conn: *mut dpiConn) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getCallTimeout(conn: *mut dpiConn, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getCurrentSchema(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getDbDomain(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getDbName(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getEdition(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getEncodingInfo(
        conn: *mut dpiConn,
        info: *mut dpiEncodingInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getExternalName(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getHandle(
        conn: *mut dpiConn,
        handle: *mut *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getInfo(conn: *mut dpiConn, info: *mut dpiConnInfo) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getInstanceName(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getInternalName(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getIsHealthy(
        conn: *mut dpiConn,
        isHealthy: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getLTXID(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getMaxOpenCursors(
        conn: *mut dpiConn,
        maxOpenCursors: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getOciAttr(
        conn: *mut dpiConn,
        handleType: u32,
        attribute: u32,
        value: *mut dpiDataBuffer,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getServiceName(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getStmtCacheSize(
        conn: *mut dpiConn,
        cacheSize: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getTransactionInProgress(
        conn: *mut dpiConn,
        txnInProgress: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newDeqOptions(
        conn: *mut dpiConn,
        options: *mut *mut dpiDeqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newEnqOptions(
        conn: *mut dpiConn,
        options: *mut *mut dpiEnqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newJson(conn: *mut dpiConn, json: *mut *mut dpiJson) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newJsonQueue(
        conn: *mut dpiConn,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        queue: *mut *mut dpiQueue,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newMsgProps(
        conn: *mut dpiConn,
        props: *mut *mut dpiMsgProps,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newQueue(
        conn: *mut dpiConn,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        payloadType: *mut dpiObjectType,
        queue: *mut *mut dpiQueue,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newVar(
        conn: *mut dpiConn,
        oracleTypeNum: dpiOracleTypeNum,
        nativeTypeNum: dpiNativeTypeNum,
        maxArraySize: u32,
        size: u32,
        sizeIsBytes: ::std::os::raw::c_int,
        isArray: ::std::os::raw::c_int,
        objType: *mut dpiObjectType,
        var: *mut *mut dpiVar,
        data: *mut *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newVector(
        conn: *mut dpiConn,
        info: *mut dpiVectorInfo,
        vector: *mut *mut dpiVector,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_prepareStmt(
        conn: *mut dpiConn,
        scrollable: ::std::os::raw::c_int,
        sql: *const ::std::os::raw::c_char,
        sqlLength: u32,
        tag: *const ::std::os::raw::c_char,
        tagLength: u32,
        stmt: *mut *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setAction(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setCallTimeout(conn: *mut dpiConn, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setClientIdentifier(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setClientInfo(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setCurrentSchema(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setDbOp(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setEcontextId(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setExternalName(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setInternalName(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setModule(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setOciAttr(
        conn: *mut dpiConn,
        handleType: u32,
        attribute: u32,
        value: *mut ::std::os::raw::c_void,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setStmtCacheSize(conn: *mut dpiConn, cacheSize: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiData_getBool(data: *mut dpiData) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiData_getBytes(data: *mut dpiData) -> *mut dpiBytes;
}
extern "C" {
    pub fn dpiData_getDouble(data: *mut dpiData) -> f64;
}
extern "C" {
    pub fn dpiData_getFloat(data: *mut dpiData) -> f32;
}
extern "C" {
    pub fn dpiData_getInt64(data: *mut dpiData) -> i64;
}
extern "C" {
    pub fn dpiData_getIntervalDS(data: *mut dpiData) -> *mut dpiIntervalDS;
}
extern "C" {
    pub fn dpiData_getIntervalYM(data: *mut dpiData) -> *mut dpiIntervalYM;
}
extern "C" {
    pub fn dpiData_getIsNull(data: *mut dpiData) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiData_getJson(data: *mut dpiData) -> *mut dpiJson;
}
extern "C" {
    pub fn dpiData_getJsonArray(data: *mut dpiData) -> *mut dpiJsonArray;
}
extern "C" {
    pub fn dpiData_getJsonObject(data: *mut dpiData) -> *mut dpiJsonObject;
}
extern "C" {
    pub fn dpiData_getLOB(data: *mut dpiData) -> *mut dpiLob;
}
extern "C" {
    pub fn dpiData_getObject(data: *mut dpiData) -> *mut dpiObject;
}
extern "C" {
    pub fn dpiData_getStmt(data: *mut dpiData) -> *mut dpiStmt;
}
extern "C" {
    pub fn dpiData_getTimestamp(data: *mut dpiData) -> *mut dpiTimestamp;
}
extern "C" {
    pub fn dpiData_getUint64(data: *mut dpiData) -> u64;
}
extern "C" {
    pub fn dpiData_setBool(data: *mut dpiData, value: ::std::os::raw::c_int);
}
extern "C" {
    pub fn dpiData_setBytes(data: *mut dpiData, ptr: *mut ::std::os::raw::c_char, length: u32);
}
extern "C" {
    pub fn dpiData_setDouble(data: *mut dpiData, value: f64);
}
extern "C" {
    pub fn dpiData_setFloat(data: *mut dpiData, value: f32);
}
extern "C" {
    pub fn dpiData_setInt64(data: *mut dpiData, value: i64);
}
extern "C" {
    pub fn dpiData_setIntervalDS(
        data: *mut dpiData,
        days: i32,
        hours: i32,
        minutes: i32,
        seconds: i32,
        fseconds: i32,
    );
}
extern "C" {
    pub fn dpiData_setIntervalYM(data: *mut dpiData, years: i32, months: i32);
}
extern "C" {
    pub fn dpiData_setLOB(data: *mut dpiData, lob: *mut dpiLob);
}
extern "C" {
    pub fn dpiData_setNull(data: *mut dpiData);
}
extern "C" {
    pub fn dpiData_setObject(data: *mut dpiData, obj: *mut dpiObject);
}
extern "C" {
    pub fn dpiData_setStmt(data: *mut dpiData, stmt: *mut dpiStmt);
}
extern "C" {
    pub fn dpiData_setTimestamp(
        data: *mut dpiData,
        year: i16,
        month: u8,
        day: u8,
        hour: u8,
        minute: u8,
        second: u8,
        fsecond: u32,
        tzHourOffset: i8,
        tzMinuteOffset: i8,
    );
}
extern "C" {
    pub fn dpiData_setUint64(data: *mut dpiData, value: u64);
}
extern "C" {
    pub fn dpiDeqOptions_addRef(options: *mut dpiDeqOptions) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getCondition(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getConsumerName(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getCorrelation(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getMode(
        options: *mut dpiDeqOptions,
        value: *mut dpiDeqMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getMsgId(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getNavigation(
        options: *mut dpiDeqOptions,
        value: *mut dpiDeqNavigation,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getTransformation(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getVisibility(
        options: *mut dpiDeqOptions,
        value: *mut dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getWait(
        options: *mut dpiDeqOptions,
        value: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setCondition(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setConsumerName(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setCorrelation(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setDeliveryMode(
        options: *mut dpiDeqOptions,
        value: dpiMessageDeliveryMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setMode(
        options: *mut dpiDeqOptions,
        value: dpiDeqMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setMsgId(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setNavigation(
        options: *mut dpiDeqOptions,
        value: dpiDeqNavigation,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setTransformation(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setVisibility(
        options: *mut dpiDeqOptions,
        value: dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setWait(options: *mut dpiDeqOptions, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_addRef(options: *mut dpiEnqOptions) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_getTransformation(
        options: *mut dpiEnqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_getVisibility(
        options: *mut dpiEnqOptions,
        value: *mut dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_setDeliveryMode(
        options: *mut dpiEnqOptions,
        value: dpiMessageDeliveryMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_setTransformation(
        options: *mut dpiEnqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_setVisibility(
        options: *mut dpiEnqOptions,
        value: dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_addRef(json: *mut dpiJson) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_setFromText(
        json: *mut dpiJson,
        value: *const ::std::os::raw::c_char,
        valueLength: u64,
        flags: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_setValue(json: *mut dpiJson, topNode: *mut dpiJsonNode)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_addRef(lob: *mut dpiLob) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getBufferSize(
        lob: *mut dpiLob,
        sizeInChars: u64,
        sizeInBytes: *mut u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getDirectoryAndFileName(
        lob: *mut dpiLob,
        directoryAlias: *mut *const ::std::os::raw::c_char,
        directoryAliasLength: *mut u32,
        fileName: *mut *const ::std::os::raw::c_char,
        fileNameLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getType(lob: *mut dpiLob, type_: *mut dpiOracleTypeNum) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_setDirectoryAndFileName(
        lob: *mut dpiLob,
        directoryAlias: *const ::std::os::raw::c_char,
        directoryAliasLength: u32,
        fileName: *const ::std::os::raw::c_char,
        fileNameLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_addRef(props: *mut dpiMsgProps) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getNumAttempts(
        props: *mut dpiMsgProps,
        value: *mut i32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getCorrelation(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getDelay(props: *mut dpiMsgProps, value: *mut i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getDeliveryMode(
        props: *mut dpiMsgProps,
        value: *mut dpiMessageDeliveryMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getEnqTime(
        props: *mut dpiMsgProps,
        value: *mut dpiTimestamp,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getExceptionQ(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getExpiration(
        props: *mut dpiMsgProps,
        value: *mut i32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getMsgId(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getOriginalMsgId(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getPayload(
        props: *mut dpiMsgProps,
        obj: *mut *mut dpiObject,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getPayloadJson(
        props: *mut dpiMsgProps,
        json: *mut *mut dpiJson,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getPriority(
        props: *mut dpiMsgProps,
        value: *mut i32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getState(
        props: *mut dpiMsgProps,
        value: *mut dpiMessageState,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setCorrelation(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setDelay(props: *mut dpiMsgProps, value: i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setExceptionQ(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setExpiration(props: *mut dpiMsgProps, value: i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setOriginalMsgId(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPayloadBytes(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPayloadJson(
        props: *mut dpiMsgProps,
        json: *mut dpiJson,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPayloadObject(
        props: *mut dpiMsgProps,
        obj: *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPriority(props: *mut dpiMsgProps, value: i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setRecipients(
        props: *mut dpiMsgProps,
        recipients: *mut dpiMsgRecipient,
        numRecipients: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_addRef(obj: *mut dpiObject) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_appendElement(
        obj: *mut dpiObject,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_copy(
        obj: *mut dpiObject,
        copiedObj: *mut *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_deleteElementByIndex(obj: *mut dpiObject, index: i32)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getAttributeValue(
        obj: *mut dpiObject,
        attr: *mut dpiObjectAttr,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getElementExistsByIndex(
        obj: *mut dpiObject,
        index: i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getElementValueByIndex(
        obj: *mut dpiObject,
        index: i32,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getFirstIndex(
        obj: *mut dpiObject,
        index: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getLastIndex(
        obj: *mut dpiObject,
        index: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getNextIndex(
        obj: *mut dpiObject,
        index: i32,
        nextIndex: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getPrevIndex(
        obj: *mut dpiObject,
        index: i32,
        prevIndex: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getSize(obj: *mut dpiObject, size: *mut i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_setAttributeValue(
        obj: *mut dpiObject,
        attr: *mut dpiObjectAttr,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_setElementValueByIndex(
        obj: *mut dpiObject,
        index: i32,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_trim(obj: *mut dpiObject, numToTrim: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectAttr_addRef(attr: *mut dpiObjectAttr) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectAttr_getInfo(
        attr: *mut dpiObjectAttr,
        info: *mut dpiObjectAttrInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_addRef(objType: *mut dpiObjectType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_createObject(
        objType: *mut dpiObjectType,
        obj: *mut *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_getAttributes(
        objType: *mut dpiObjectType,
        numAttributes: u16,
        attributes: *mut *mut dpiObjectAttr,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_getInfo(
        objType: *mut dpiObjectType,
        info: *mut dpiObjectTypeInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_addRef(pool: *mut dpiPool) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getBusyCount(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getEncodingInfo(
        pool: *mut dpiPool,
        info: *mut dpiEncodingInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getGetMode(
        pool: *mut dpiPool,
        value: *mut dpiPoolGetMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getMaxLifetimeSession(
        pool: *mut dpiPool,
        value: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getMaxSessionsPerShard(
        pool: *mut dpiPool,
        value: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getOpenCount(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getSodaMetadataCache(
        pool: *mut dpiPool,
        enabled: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getStmtCacheSize(
        pool: *mut dpiPool,
        cacheSize: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getTimeout(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getWaitTimeout(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getPingInterval(
        pool: *mut dpiPool,
        value: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setAccessToken(
        pool: *mut dpiPool,
        params: *mut dpiAccessToken,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setGetMode(pool: *mut dpiPool, value: dpiPoolGetMode) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setMaxLifetimeSession(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setMaxSessionsPerShard(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setSodaMetadataCache(
        pool: *mut dpiPool,
        enabled: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setStmtCacheSize(pool: *mut dpiPool, cacheSize: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setTimeout(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setWaitTimeout(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setPingInterval(
        pool: *mut dpiPool,
        value: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_addRef(queue: *mut dpiQueue) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_getDeqOptions(
        queue: *mut dpiQueue,
        options: *mut *mut dpiDeqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_getEnqOptions(
        queue: *mut dpiQueue,
        options: *mut *mut dpiEnqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_addRef(coll: *mut dpiSodaColl) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_getMetadata(
        coll: *mut dpiSodaColl,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_getName(
        coll: *mut dpiSodaColl,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaCollCursor_addRef(cursor: *mut dpiSodaCollCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaCollCursor_close(cursor: *mut dpiSodaCollCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_addRef(db: *mut dpiSodaDb) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_createDocument(
        db: *mut dpiSodaDb,
        key: *const ::std::os::raw::c_char,
        keyLength: u32,
        content: *const ::std::os::raw::c_char,
        contentLength: u32,
        mediaType: *const ::std::os::raw::c_char,
        mediaTypeLength: u32,
        flags: u32,
        doc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_createJsonDocument(
        db: *mut dpiSodaDb,
        key: *const ::std::os::raw::c_char,
        keyLength: u32,
        content: *const dpiJsonNode,
        flags: u32,
        doc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_freeCollectionNames(
        db: *mut dpiSodaDb,
        names: *mut dpiStringList,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_addRef(cursor: *mut dpiSodaDoc) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getContent(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
        encoding: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getCreatedOn(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getIsJson(
        doc: *mut dpiSodaDoc,
        isJson: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getJsonContent(
        doc: *mut dpiSodaDoc,
        value: *mut *mut dpiJson,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getKey(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getLastModified(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getMediaType(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getVersion(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDocCursor_addRef(cursor: *mut dpiSodaDocCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDocCursor_close(cursor: *mut dpiSodaDocCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_addRef(stmt: *mut dpiStmt) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindByName(
        stmt: *mut dpiStmt,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        var: *mut dpiVar,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindByPos(
        stmt: *mut dpiStmt,
        pos: u32,
        var: *mut dpiVar,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindValueByName(
        stmt: *mut dpiStmt,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        nativeTypeNum: dpiNativeTypeNum,
        data: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindValueByPos(
        stmt: *mut dpiStmt,
        pos: u32,
        nativeTypeNum: dpiNativeTypeNum,
        data: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_close(
        stmt: *mut dpiStmt,
        tag: *const ::std::os::raw::c_char,
        tagLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_define(stmt: *mut dpiStmt, pos: u32, var: *mut dpiVar) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_defineValue(
        stmt: *mut dpiStmt,
        pos: u32,
        oracleTypeNum: dpiOracleTypeNum,
        nativeTypeNum: dpiNativeTypeNum,
        size: u32,
        sizeIsBytes: ::std::os::raw::c_int,
        objType: *mut dpiObjectType,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBatchErrorCount(stmt: *mut dpiStmt, count: *mut u32)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBatchErrors(
        stmt: *mut dpiStmt,
        numErrors: u32,
        errors: *mut dpiErrorInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBindCount(stmt: *mut dpiStmt, count: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBindNames(
        stmt: *mut dpiStmt,
        numBindNames: *mut u32,
        bindNames: *mut *const ::std::os::raw::c_char,
        bindNameLengths: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getFetchArraySize(
        stmt: *mut dpiStmt,
        arraySize: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getImplicitResult(
        stmt: *mut dpiStmt,
        implicitResult: *mut *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getInfo(stmt: *mut dpiStmt, info: *mut dpiStmtInfo) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getLastRowid(
        stmt: *mut dpiStmt,
        rowid: *mut *mut dpiRowid,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getNumQueryColumns(
        stmt: *mut dpiStmt,
        numQueryColumns: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getOciAttr(
        stmt: *mut dpiStmt,
        attribute: u32,
        value: *mut dpiDataBuffer,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getPrefetchRows(stmt: *mut dpiStmt, numRows: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getQueryInfo(
        stmt: *mut dpiStmt,
        pos: u32,
        info: *mut dpiQueryInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getQueryValue(
        stmt: *mut dpiStmt,
        pos: u32,
        nativeTypeNum: *mut dpiNativeTypeNum,
        data: *mut *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getRowCount(stmt: *mut dpiStmt, count: *mut u64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getRowCounts(
        stmt: *mut dpiStmt,
        numRowCounts: *mut u32,
        rowCounts: *mut *mut u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getSubscrQueryId(stmt: *mut dpiStmt, queryId: *mut u64)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_setFetchArraySize(stmt: *mut dpiStmt, arraySize: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_setOciAttr(
        stmt: *mut dpiStmt,
        attribute: u32,
        value: *mut ::std::os::raw::c_void,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_setPrefetchRows(stmt: *mut dpiStmt, numRows: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_deleteFromCache(stmt: *mut dpiStmt) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiRowid_addRef(rowid: *mut dpiRowid) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiRowid_getStringValue(
        rowid: *mut dpiRowid,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiRowid_release(subscr: *mut dpiRowid) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSubscr_addRef(subscr: *mut dpiSubscr) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSubscr_prepareStmt(
        subscr: *mut dpiSubscr,
        sql: *const ::std::os::raw::c_char,
        sqlLength: u32,
        stmt: *mut *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_addRef(var: *mut dpiVar) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_copyData(
        var: *mut dpiVar,
        pos: u32,
        sourceVar: *mut dpiVar,
        sourcePos: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_getNumElementsInArray(
        var: *mut dpiVar,
        numElements: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_getReturnedData(
        var: *mut dpiVar,
        pos: u32,
        numElements: *mut u32,
        data: *mut *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_getSizeInBytes(var: *mut dpiVar, sizeInBytes: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromJson(
        var: *mut dpiVar,
        pos: u32,
        json: *mut dpiJson,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromLob(var: *mut dpiVar, pos: u32, lob: *mut dpiLob)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromObject(
        var: *mut dpiVar,
        pos: u32,
        obj: *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromRowid(
        var: *mut dpiVar,
        pos: u32,
        rowid: *mut dpiRowid,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromStmt(
        var: *mut dpiVar,
        pos: u32,
        stmt: *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromVector(
        var: *mut dpiVar,
        pos: u32,
        vector: *mut dpiVector,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setNumElementsInArray(
        var: *mut dpiVar,
        numElements: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVector_addRef(vector: *mut dpiVector) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVector_getValue(
        vector: *mut dpiVector,
        info: *mut dpiVectorInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVector_release(vector: *mut dpiVector) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVector_setValue(
        vector: *mut dpiVector,
        info: *mut dpiVectorInfo,
    ) -> ::std::os::raw::c_int;
}