pub const DPI_MAJOR_VERSION: u32 = 5;
pub const DPI_MINOR_VERSION: u32 = 4;
pub const DPI_PATCH_LEVEL: u32 = 0;
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,
fsceconds: 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;
}