use std::any::Any;
use std::collections::HashMap;
use std::ffi::{c_char, c_int, c_void, CStr, CString};
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use crate::error::Error;
use crate::ffi::{
NativeDbCallbacks, NativeDbCell, NativeDbResult, NativeDbRow, NativeDbValue,
NativeObjectCallbacks, DB_VALUE_BLOB, DB_VALUE_DOUBLE, DB_VALUE_INT64, DB_VALUE_NULL,
DB_VALUE_TEXT,
};
#[derive(Clone, Debug, PartialEq)]
pub enum DbValue {
Null,
Int64(i64),
Double(f64),
Text(String),
Blob(Vec<u8>),
}
pub type DbRow = Vec<(String, DbValue)>;
pub struct ProviderTransaction {
inner: Box<dyn Any + Send>,
}
impl ProviderTransaction {
pub fn new<T: Send + 'static>(value: T) -> Self {
Self {
inner: Box::new(value),
}
}
pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
self.inner.downcast_ref()
}
}
pub trait DbProvider: Send + 'static {
fn execute(
&self,
query: &str,
params: &[DbValue],
transaction: Option<&ProviderTransaction>,
) -> Result<Vec<DbRow>, Error>;
fn begin(&self, parent: Option<&ProviderTransaction>) -> Result<ProviderTransaction, Error>;
fn commit(&self, transaction: &ProviderTransaction) -> Result<(), Error>;
fn rollback(&self, transaction: &ProviderTransaction) -> Result<(), Error>;
fn release_transaction(&self, _transaction: ProviderTransaction) {}
}
pub trait ObjectStoreProvider: Send + 'static {
fn begin(&self, parent: Option<&ProviderTransaction>) -> Result<ProviderTransaction, Error>;
fn put(
&self,
object_id: &[u8],
data: &[u8],
transaction: &ProviderTransaction,
) -> Result<(), Error>;
fn get(
&self,
object_id: &[u8],
transaction: &ProviderTransaction,
) -> Result<Option<Vec<u8>>, Error>;
fn exists(&self, object_id: &[u8], transaction: &ProviderTransaction) -> Result<bool, Error>;
fn delete(&self, object_id: &[u8], transaction: &ProviderTransaction) -> Result<bool, Error>;
fn commit(&self, transaction: &ProviderTransaction) -> Result<(), Error>;
fn rollback(&self, transaction: &ProviderTransaction) -> Result<(), Error>;
fn release_transaction(&self, _transaction: ProviderTransaction) {}
}
pub(crate) struct AllocatedResult {
#[allow(dead_code)]
names: Vec<CString>,
#[allow(dead_code)]
texts: Vec<CString>,
#[allow(dead_code)]
blobs: Vec<Vec<u8>>,
cells: Vec<Vec<NativeDbCell>>,
rows: Vec<NativeDbRow>,
}
impl AllocatedResult {
fn empty() -> Self {
Self {
names: Vec::new(),
texts: Vec::new(),
blobs: Vec::new(),
cells: Vec::new(),
rows: Vec::new(),
}
}
pub(crate) fn native_view(&self) -> NativeDbResult {
NativeDbResult {
rows: if self.rows.is_empty() {
std::ptr::null()
} else {
self.rows.as_ptr()
},
row_count: self.rows.len(),
}
}
}
pub(crate) fn db_value_from_native(value: &NativeDbValue) -> DbValue {
match value.type_ {
x if x == DB_VALUE_INT64 => DbValue::Int64(value.int64_value),
x if x == DB_VALUE_DOUBLE => DbValue::Double(value.double_value),
x if x == DB_VALUE_TEXT => {
if value.text_value.is_null() {
DbValue::Text(String::new())
} else {
DbValue::Text(
unsafe { CStr::from_ptr(value.text_value) }
.to_string_lossy()
.into_owned(),
)
}
}
x if x == DB_VALUE_BLOB => {
if value.blob_data.is_null() || value.blob_size == 0 {
DbValue::Blob(Vec::new())
} else {
DbValue::Blob(
unsafe { std::slice::from_raw_parts(value.blob_data, value.blob_size) }.to_vec(),
)
}
}
_ => DbValue::Null,
}
}
fn cstring_lossy(value: &str) -> CString {
CString::new(value.replace('\0', "")).unwrap_or_else(|_| CString::new("error").unwrap())
}
fn db_value_to_native(value: &DbValue, keep: &mut AllocatedResult) -> NativeDbValue {
match value {
DbValue::Null => NativeDbValue {
type_: DB_VALUE_NULL,
int64_value: 0,
double_value: 0.0,
text_value: std::ptr::null(),
blob_data: std::ptr::null(),
blob_size: 0,
},
DbValue::Int64(v) => NativeDbValue {
type_: DB_VALUE_INT64,
int64_value: *v,
double_value: 0.0,
text_value: std::ptr::null(),
blob_data: std::ptr::null(),
blob_size: 0,
},
DbValue::Double(v) => NativeDbValue {
type_: DB_VALUE_DOUBLE,
int64_value: 0,
double_value: *v,
text_value: std::ptr::null(),
blob_data: std::ptr::null(),
blob_size: 0,
},
DbValue::Text(s) => {
keep.texts.push(cstring_lossy(s));
let text_value = keep.texts.last().unwrap().as_ptr();
NativeDbValue {
type_: DB_VALUE_TEXT,
int64_value: 0,
double_value: 0.0,
text_value,
blob_data: std::ptr::null(),
blob_size: 0,
}
}
DbValue::Blob(b) => {
keep.blobs.push(b.clone());
let stored = keep.blobs.last().unwrap();
NativeDbValue {
type_: DB_VALUE_BLOB,
int64_value: 0,
double_value: 0.0,
text_value: std::ptr::null(),
blob_data: stored.as_ptr(),
blob_size: stored.len(),
}
}
}
}
pub(crate) fn allocate_db_result(rows: Vec<DbRow>) -> AllocatedResult {
let mut keep = AllocatedResult::empty();
keep.cells.reserve(rows.len());
keep.rows.reserve(rows.len());
for row in rows {
let mut cells = Vec::with_capacity(row.len());
for (name, value) in row {
keep.names.push(cstring_lossy(&name));
let column_name = keep.names.last().unwrap().as_ptr();
let native_value = db_value_to_native(&value, &mut keep);
cells.push(NativeDbCell {
column_name,
value: native_value,
});
}
keep.cells.push(cells);
let last = keep.cells.last().unwrap();
keep.rows.push(NativeDbRow {
cells: if last.is_empty() {
std::ptr::null()
} else {
last.as_ptr()
},
cell_count: last.len(),
});
}
keep
}
fn bytes_from_c(data: *const u8, size: usize) -> Vec<u8> {
if data.is_null() || size == 0 {
Vec::new()
} else {
unsafe { std::slice::from_raw_parts(data, size) }.to_vec()
}
}
fn set_error(errors: &Mutex<Vec<CString>>, out_error: *mut *const c_char, message: &str) -> c_int {
let encoded = cstring_lossy(message);
if !out_error.is_null() {
unsafe {
*out_error = encoded.as_ptr();
}
}
if let Ok(mut guard) = errors.lock() {
guard.push(encoded);
}
1
}
fn tx_handle(ptr: *mut c_void) -> usize {
ptr as usize
}
fn handle_ptr(handle: usize) -> *mut c_void {
handle as *mut c_void
}
fn lookup_tx(
map: &HashMap<usize, Arc<ProviderTransaction>>,
handle: usize,
) -> Option<Arc<ProviderTransaction>> {
if handle == 0 {
None
} else {
map.get(&handle).cloned()
}
}
pub(crate) struct DbBridge {
provider: Box<dyn DbProvider>,
transactions: Mutex<HashMap<usize, Arc<ProviderTransaction>>>,
next_transaction: AtomicUsize,
results: Mutex<HashMap<usize, AllocatedResult>>,
errors: Mutex<Vec<CString>>,
callbacks: NativeDbCallbacks,
}
impl DbBridge {
pub(crate) fn new(provider: Box<dyn DbProvider>) -> Self {
Self {
provider,
transactions: Mutex::new(HashMap::new()),
next_transaction: AtomicUsize::new(1),
results: Mutex::new(HashMap::new()),
errors: Mutex::new(Vec::new()),
callbacks: NativeDbCallbacks {
struct_size: std::mem::size_of::<NativeDbCallbacks>(),
execute: db_execute,
begin: db_begin,
commit: db_commit,
rollback: db_rollback,
release_transaction: db_release_transaction,
release_result: db_release_result,
},
}
}
pub(crate) fn callbacks(&self) -> &NativeDbCallbacks {
&self.callbacks
}
pub(crate) fn user_data(&self) -> *mut c_void {
(self as *const DbBridge as *mut DbBridge).cast()
}
}
pub(crate) struct ObjectBridge {
provider: Box<dyn ObjectStoreProvider>,
transactions: Mutex<HashMap<usize, Arc<ProviderTransaction>>>,
next_transaction: AtomicUsize,
blobs: Mutex<HashMap<usize, Vec<u8>>>,
errors: Mutex<Vec<CString>>,
callbacks: NativeObjectCallbacks,
}
impl ObjectBridge {
pub(crate) fn new(provider: Box<dyn ObjectStoreProvider>) -> Self {
Self {
provider,
transactions: Mutex::new(HashMap::new()),
next_transaction: AtomicUsize::new(1),
blobs: Mutex::new(HashMap::new()),
errors: Mutex::new(Vec::new()),
callbacks: NativeObjectCallbacks {
struct_size: std::mem::size_of::<NativeObjectCallbacks>(),
begin: object_begin,
put: object_put,
get: object_get,
exists: object_exists,
delete_object: object_delete,
commit: object_commit,
rollback: object_rollback,
release_transaction: object_release_transaction,
release_blob: object_release_blob,
},
}
}
pub(crate) fn callbacks(&self) -> &NativeObjectCallbacks {
&self.callbacks
}
pub(crate) fn user_data(&self) -> *mut c_void {
(self as *const ObjectBridge as *mut ObjectBridge).cast()
}
}
unsafe fn db_bridge<'a>(user_data: *mut c_void) -> &'a DbBridge {
&*user_data.cast::<DbBridge>()
}
unsafe fn object_bridge<'a>(user_data: *mut c_void) -> &'a ObjectBridge {
&*user_data.cast::<ObjectBridge>()
}
unsafe extern "C" fn db_execute(
user_data: *mut c_void,
transaction: *mut c_void,
query: *const c_char,
params: *const NativeDbValue,
param_count: usize,
out_result: *mut NativeDbResult,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { db_bridge(user_data) };
let query = if query.is_null() {
String::new()
} else {
unsafe { CStr::from_ptr(query) }
.to_string_lossy()
.into_owned()
};
let native_params = if params.is_null() || param_count == 0 {
Vec::new()
} else {
unsafe { std::slice::from_raw_parts(params, param_count) }.to_vec()
};
let py_params: Vec<DbValue> = native_params.iter().map(db_value_from_native).collect();
let handle = tx_handle(transaction);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("db provider lock poisoned"))
.map(|guard| lookup_tx(&guard, handle))?;
bridge
.provider
.execute(&query, &py_params, tx.as_deref())
}));
match result {
Ok(Ok(rows)) => {
let allocated = allocate_db_result(rows);
if !out_result.is_null() {
unsafe {
*out_result = allocated.native_view();
}
}
if let Ok(mut results) = bridge.results.lock() {
results.insert(out_result as usize, allocated);
}
0
}
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(&bridge.errors, out_error, "panic in DbProvider::execute"),
}
}
unsafe extern "C" fn db_begin(
user_data: *mut c_void,
parent_transaction: *mut c_void,
out_transaction: *mut *mut c_void,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { db_bridge(user_data) };
let parent_handle = tx_handle(parent_transaction);
let result = catch_unwind(AssertUnwindSafe(|| {
let parent = bridge
.transactions
.lock()
.map_err(|_| Error::new("db provider lock poisoned"))
.map(|guard| lookup_tx(&guard, parent_handle))?;
bridge.provider.begin(parent.as_deref())
}));
match result {
Ok(Ok(tx)) => {
let handle = bridge.next_transaction.fetch_add(1, Ordering::Relaxed);
if let Ok(mut map) = bridge.transactions.lock() {
map.insert(handle, Arc::new(tx));
}
if !out_transaction.is_null() {
unsafe {
*out_transaction = handle_ptr(handle);
}
}
0
}
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(&bridge.errors, out_error, "panic in DbProvider::begin"),
}
}
unsafe extern "C" fn db_commit(
user_data: *mut c_void,
transaction: *mut c_void,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { db_bridge(user_data) };
let handle = tx_handle(transaction);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("db provider lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown db transaction"))
})?;
bridge.provider.commit(tx.as_ref())
}));
match result {
Ok(Ok(())) => 0,
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(&bridge.errors, out_error, "panic in DbProvider::commit"),
}
}
unsafe extern "C" fn db_rollback(
user_data: *mut c_void,
transaction: *mut c_void,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { db_bridge(user_data) };
let handle = tx_handle(transaction);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("db provider lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown db transaction"))
})?;
bridge.provider.rollback(tx.as_ref())
}));
match result {
Ok(Ok(())) => 0,
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(&bridge.errors, out_error, "panic in DbProvider::rollback"),
}
}
unsafe extern "C" fn db_release_transaction(user_data: *mut c_void, transaction: *mut c_void) {
if user_data.is_null() {
return;
}
let bridge = unsafe { db_bridge(user_data) };
let handle = tx_handle(transaction);
let tx = bridge
.transactions
.lock()
.ok()
.and_then(|mut map| map.remove(&handle));
if let Some(tx) = tx {
if let Ok(tx) = Arc::try_unwrap(tx) {
let _ = catch_unwind(AssertUnwindSafe(|| bridge.provider.release_transaction(tx)));
}
}
}
unsafe extern "C" fn db_release_result(user_data: *mut c_void, result: *mut NativeDbResult) {
if user_data.is_null() {
return;
}
let bridge = unsafe { db_bridge(user_data) };
if let Ok(mut results) = bridge.results.lock() {
results.remove(&(result as usize));
}
}
unsafe extern "C" fn object_begin(
user_data: *mut c_void,
parent_transaction: *mut c_void,
out_transaction: *mut *mut c_void,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { object_bridge(user_data) };
let parent_handle = tx_handle(parent_transaction);
let result = catch_unwind(AssertUnwindSafe(|| {
let parent = bridge
.transactions
.lock()
.map_err(|_| Error::new("object store lock poisoned"))
.map(|guard| lookup_tx(&guard, parent_handle))?;
bridge.provider.begin(parent.as_deref())
}));
match result {
Ok(Ok(tx)) => {
let handle = bridge.next_transaction.fetch_add(1, Ordering::Relaxed);
if let Ok(mut map) = bridge.transactions.lock() {
map.insert(handle, Arc::new(tx));
}
if !out_transaction.is_null() {
unsafe {
*out_transaction = handle_ptr(handle);
}
}
0
}
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(
&bridge.errors,
out_error,
"panic in ObjectStoreProvider::begin",
),
}
}
unsafe extern "C" fn object_put(
user_data: *mut c_void,
transaction: *mut c_void,
object_id: *const u8,
object_id_size: usize,
data: *const u8,
data_size: usize,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { object_bridge(user_data) };
let handle = tx_handle(transaction);
let id = bytes_from_c(object_id, object_id_size);
let payload = bytes_from_c(data, data_size);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("object store lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown object transaction"))
})?;
bridge.provider.put(&id, &payload, tx.as_ref())
}));
match result {
Ok(Ok(())) => 0,
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(&bridge.errors, out_error, "panic in ObjectStoreProvider::put"),
}
}
unsafe extern "C" fn object_get(
user_data: *mut c_void,
transaction: *mut c_void,
object_id: *const u8,
object_id_size: usize,
out_data: *mut *const u8,
out_data_size: *mut usize,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { object_bridge(user_data) };
let handle = tx_handle(transaction);
let id = bytes_from_c(object_id, object_id_size);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("object store lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown object transaction"))
})?;
bridge.provider.get(&id, tx.as_ref())
}));
match result {
Ok(Ok(None)) => {
if !out_data.is_null() {
unsafe {
*out_data = std::ptr::null();
}
}
if !out_data_size.is_null() {
unsafe {
*out_data_size = 0;
}
}
0
}
Ok(Ok(Some(data))) => {
let ptr = data.as_ptr();
let len = data.len();
if let Ok(mut blobs) = bridge.blobs.lock() {
blobs.insert(ptr as usize, data);
}
if !out_data.is_null() {
unsafe {
*out_data = ptr;
}
}
if !out_data_size.is_null() {
unsafe {
*out_data_size = len;
}
}
0
}
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(&bridge.errors, out_error, "panic in ObjectStoreProvider::get"),
}
}
unsafe extern "C" fn object_exists(
user_data: *mut c_void,
transaction: *mut c_void,
object_id: *const u8,
object_id_size: usize,
out_exists: *mut c_int,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { object_bridge(user_data) };
let handle = tx_handle(transaction);
let id = bytes_from_c(object_id, object_id_size);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("object store lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown object transaction"))
})?;
bridge.provider.exists(&id, tx.as_ref())
}));
match result {
Ok(Ok(exists)) => {
if !out_exists.is_null() {
unsafe {
*out_exists = i32::from(exists);
}
}
0
}
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(
&bridge.errors,
out_error,
"panic in ObjectStoreProvider::exists",
),
}
}
unsafe extern "C" fn object_delete(
user_data: *mut c_void,
transaction: *mut c_void,
object_id: *const u8,
object_id_size: usize,
out_deleted: *mut c_int,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { object_bridge(user_data) };
let handle = tx_handle(transaction);
let id = bytes_from_c(object_id, object_id_size);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("object store lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown object transaction"))
})?;
bridge.provider.delete(&id, tx.as_ref())
}));
match result {
Ok(Ok(deleted)) => {
if !out_deleted.is_null() {
unsafe {
*out_deleted = i32::from(deleted);
}
}
0
}
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(
&bridge.errors,
out_error,
"panic in ObjectStoreProvider::delete",
),
}
}
unsafe extern "C" fn object_commit(
user_data: *mut c_void,
transaction: *mut c_void,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { object_bridge(user_data) };
let handle = tx_handle(transaction);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("object store lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown object transaction"))
})?;
bridge.provider.commit(tx.as_ref())
}));
match result {
Ok(Ok(())) => 0,
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(
&bridge.errors,
out_error,
"panic in ObjectStoreProvider::commit",
),
}
}
unsafe extern "C" fn object_rollback(
user_data: *mut c_void,
transaction: *mut c_void,
out_error: *mut *const c_char,
) -> c_int {
if user_data.is_null() {
return 1;
}
let bridge = unsafe { object_bridge(user_data) };
let handle = tx_handle(transaction);
let result = catch_unwind(AssertUnwindSafe(|| {
let tx = bridge
.transactions
.lock()
.map_err(|_| Error::new("object store lock poisoned"))
.and_then(|guard| {
lookup_tx(&guard, handle).ok_or_else(|| Error::new("unknown object transaction"))
})?;
bridge.provider.rollback(tx.as_ref())
}));
match result {
Ok(Ok(())) => 0,
Ok(Err(err)) => set_error(&bridge.errors, out_error, &err.to_string()),
Err(_) => set_error(
&bridge.errors,
out_error,
"panic in ObjectStoreProvider::rollback",
),
}
}
unsafe extern "C" fn object_release_transaction(user_data: *mut c_void, transaction: *mut c_void) {
if user_data.is_null() {
return;
}
let bridge = unsafe { object_bridge(user_data) };
let handle = tx_handle(transaction);
let tx = bridge
.transactions
.lock()
.ok()
.and_then(|mut map| map.remove(&handle));
if let Some(tx) = tx {
if let Ok(tx) = Arc::try_unwrap(tx) {
let _ = catch_unwind(AssertUnwindSafe(|| bridge.provider.release_transaction(tx)));
}
}
}
unsafe extern "C" fn object_release_blob(user_data: *mut c_void, data: *const u8, _data_size: usize) {
if user_data.is_null() || data.is_null() {
return;
}
let bridge = unsafe { object_bridge(user_data) };
if let Ok(mut blobs) = bridge.blobs.lock() {
blobs.remove(&(data as usize));
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ffi::{NativeDbResult, NativeDbValue, DB_VALUE_TEXT};
#[test]
fn db_value_roundtrip_null_int_double_text_blob() {
let cases = [
DbValue::Null,
DbValue::Int64(-7),
DbValue::Int64(0),
DbValue::Double(1.5),
DbValue::Text("hello".into()),
DbValue::Text(String::new()),
DbValue::Blob(vec![0x00, 0xff, 0x01]),
DbValue::Blob(Vec::new()),
];
for value in cases {
let mut keep = AllocatedResult::empty();
let native = db_value_to_native(&value, &mut keep);
let got = db_value_from_native(&native);
assert_eq!(got, value);
}
let unknown = NativeDbValue {
type_: 99,
int64_value: 99,
double_value: 1.0,
text_value: std::ptr::null(),
blob_data: std::ptr::null(),
blob_size: 0,
};
assert_eq!(db_value_from_native(&unknown), DbValue::Null);
}
#[test]
fn allocate_db_result_preserves_rows_until_drop() {
let rows = vec![
vec![
("id".into(), DbValue::Int64(3)),
("name".into(), DbValue::Text("bailey".into())),
],
vec![("blob".into(), DbValue::Blob(vec![1, 2, 3]))],
];
let allocated = allocate_db_result(rows);
let view = allocated.native_view();
assert_eq!(view.row_count, 2);
let native_rows = unsafe { std::slice::from_raw_parts(view.rows, view.row_count) };
assert_eq!(native_rows[0].cell_count, 2);
let cells = unsafe { std::slice::from_raw_parts(native_rows[0].cells, 2) };
let name = unsafe { CStr::from_ptr(cells[0].column_name) }
.to_str()
.unwrap();
assert_eq!(name, "id");
assert_eq!(db_value_from_native(&cells[0].value), DbValue::Int64(3));
let name = unsafe { CStr::from_ptr(cells[1].column_name) }
.to_str()
.unwrap();
assert_eq!(name, "name");
assert_eq!(
db_value_from_native(&cells[1].value),
DbValue::Text("bailey".into())
);
let blob_cells = unsafe { std::slice::from_raw_parts(native_rows[1].cells, 1) };
assert_eq!(
db_value_from_native(&blob_cells[0].value),
DbValue::Blob(vec![1, 2, 3])
);
}
#[test]
fn native_callback_struct_sizes_match_c_layout_64bit() {
if cfg!(target_pointer_width = "64") {
assert_eq!(std::mem::size_of::<NativeDbValue>(), 48);
assert_eq!(std::mem::size_of::<NativeDbCallbacks>(), 56);
assert_eq!(std::mem::size_of::<NativeObjectCallbacks>(), 80);
}
}
struct MemoryDb;
impl DbProvider for MemoryDb {
fn execute(
&self,
query: &str,
params: &[DbValue],
_transaction: Option<&ProviderTransaction>,
) -> Result<Vec<DbRow>, Error> {
assert_eq!(query, "select ?");
assert_eq!(params, &[DbValue::Text("x".into())]);
Ok(vec![vec![
("id".into(), DbValue::Int64(9)),
("blob".into(), DbValue::Blob(vec![7, 8])),
]])
}
fn begin(
&self,
_parent: Option<&ProviderTransaction>,
) -> Result<ProviderTransaction, Error> {
Ok(ProviderTransaction::new(1u8))
}
fn commit(&self, _transaction: &ProviderTransaction) -> Result<(), Error> {
Ok(())
}
fn rollback(&self, _transaction: &ProviderTransaction) -> Result<(), Error> {
Ok(())
}
}
struct MemoryObjects;
impl ObjectStoreProvider for MemoryObjects {
fn begin(
&self,
_parent: Option<&ProviderTransaction>,
) -> Result<ProviderTransaction, Error> {
Ok(ProviderTransaction::new(1u8))
}
fn put(
&self,
object_id: &[u8],
data: &[u8],
_transaction: &ProviderTransaction,
) -> Result<(), Error> {
assert_eq!(object_id, b"id");
assert_eq!(data, b"payload");
Ok(())
}
fn get(
&self,
object_id: &[u8],
_transaction: &ProviderTransaction,
) -> Result<Option<Vec<u8>>, Error> {
assert_eq!(object_id, b"id");
Ok(Some(b"payload".to_vec()))
}
fn exists(
&self,
_object_id: &[u8],
_transaction: &ProviderTransaction,
) -> Result<bool, Error> {
Ok(true)
}
fn delete(
&self,
_object_id: &[u8],
_transaction: &ProviderTransaction,
) -> Result<bool, Error> {
Ok(true)
}
fn commit(&self, _transaction: &ProviderTransaction) -> Result<(), Error> {
Ok(())
}
fn rollback(&self, _transaction: &ProviderTransaction) -> Result<(), Error> {
Ok(())
}
}
#[test]
fn db_callbacks_execute_and_begin_without_native() {
let bridge = DbBridge::new(Box::new(MemoryDb));
let mut tx = std::ptr::null_mut();
let mut err = std::ptr::null();
let begin_status = unsafe {
(bridge.callbacks().begin)(
bridge.user_data(),
std::ptr::null_mut(),
&mut tx,
&mut err,
)
};
assert_eq!(begin_status, 0);
assert!(!tx.is_null());
let query = CString::new("select ?").unwrap();
let text = CString::new("x").unwrap();
let param = NativeDbValue {
type_: DB_VALUE_TEXT,
int64_value: 0,
double_value: 0.0,
text_value: text.as_ptr(),
blob_data: std::ptr::null(),
blob_size: 0,
};
let mut result = NativeDbResult {
rows: std::ptr::null(),
row_count: 0,
};
let exec_status = unsafe {
(bridge.callbacks().execute)(
bridge.user_data(),
tx,
query.as_ptr(),
¶m,
1,
&mut result,
&mut err,
)
};
assert_eq!(exec_status, 0);
assert_eq!(result.row_count, 1);
let rows = unsafe { std::slice::from_raw_parts(result.rows, 1) };
let cells = unsafe { std::slice::from_raw_parts(rows[0].cells, 2) };
assert_eq!(db_value_from_native(&cells[0].value), DbValue::Int64(9));
assert_eq!(
db_value_from_native(&cells[1].value),
DbValue::Blob(vec![7, 8])
);
unsafe {
(bridge.callbacks().release_result)(bridge.user_data(), &mut result);
(bridge.callbacks().commit)(bridge.user_data(), tx, &mut err);
(bridge.callbacks().release_transaction)(bridge.user_data(), tx);
}
}
#[test]
fn object_callbacks_put_get_without_native() {
let bridge = ObjectBridge::new(Box::new(MemoryObjects));
let mut tx = std::ptr::null_mut();
let mut err = std::ptr::null();
let begin_status = unsafe {
(bridge.callbacks().begin)(
bridge.user_data(),
std::ptr::null_mut(),
&mut tx,
&mut err,
)
};
assert_eq!(begin_status, 0);
let id = b"id";
let payload = b"payload";
let put_status = unsafe {
(bridge.callbacks().put)(
bridge.user_data(),
tx,
id.as_ptr(),
id.len(),
payload.as_ptr(),
payload.len(),
&mut err,
)
};
assert_eq!(put_status, 0);
let mut out = std::ptr::null();
let mut out_len = 0usize;
let get_status = unsafe {
(bridge.callbacks().get)(
bridge.user_data(),
tx,
id.as_ptr(),
id.len(),
&mut out,
&mut out_len,
&mut err,
)
};
assert_eq!(get_status, 0);
assert_eq!(out_len, 7);
let got = unsafe { std::slice::from_raw_parts(out, out_len) };
assert_eq!(got, b"payload");
unsafe {
(bridge.callbacks().release_blob)(bridge.user_data(), out, out_len);
(bridge.callbacks().release_transaction)(bridge.user_data(), tx);
}
}
}