#![allow(clippy::rc_buffer)]
use std::ptr::null_mut;
use std::slice;
use std::sync::atomic::{AtomicPtr, Ordering};
use std::sync::{Arc, Weak};
use crate::HashMap;
use crate::column::ColumnIndex;
use crate::error::Error;
use crate::ext::ustr::UStr;
use crate::row::Row;
use crate::sqlite::statement::{StatementHandle, StatementHandleRef};
use crate::sqlite::{Sqlite, SqliteColumn, SqliteValue, SqliteValueRef};
pub struct SqliteRow {
pub(crate) statement: StatementHandleRef,
pub(crate) values: Arc<AtomicPtr<SqliteValue>>,
pub(crate) num_values: usize,
pub(crate) columns: Arc<Vec<SqliteColumn>>,
pub(crate) column_names: Arc<HashMap<UStr, usize>>,
}
impl crate::row::private_row::Sealed for SqliteRow {}
unsafe impl Send for SqliteRow {}
unsafe impl Sync for SqliteRow {}
impl SqliteRow {
pub(crate) fn current(
statement: StatementHandleRef,
columns: &Arc<Vec<SqliteColumn>>,
column_names: &Arc<HashMap<UStr, usize>>,
) -> (Self, Weak<AtomicPtr<SqliteValue>>) {
let values = Arc::new(AtomicPtr::new(null_mut()));
let weak_values = Arc::downgrade(&values);
let size = statement.column_count();
let row = Self {
statement,
values,
num_values: size,
columns: Arc::clone(columns),
column_names: Arc::clone(column_names),
};
(row, weak_values)
}
#[allow(clippy::needless_range_loop)]
pub(crate) fn inflate(
statement: &StatementHandle,
columns: &[SqliteColumn],
values_ref: &AtomicPtr<SqliteValue>,
) {
let size = statement.column_count();
let mut values = Vec::with_capacity(size);
for i in 0..size {
values.push(unsafe {
let raw = statement.column_value(i);
SqliteValue::new(raw, columns[i].type_info.clone())
});
}
let values_ptr = Box::into_raw(values.into_boxed_slice()) as *mut SqliteValue;
values_ref.store(values_ptr, Ordering::Release);
}
pub(crate) fn inflate_if_needed(
statement: &StatementHandle,
columns: &[SqliteColumn],
weak_values_ref: Option<Weak<AtomicPtr<SqliteValue>>>,
) {
if let Some(v) = weak_values_ref.and_then(|v| v.upgrade()) {
SqliteRow::inflate(statement, &columns, &v);
}
}
}
impl Row for SqliteRow {
type Database = Sqlite;
fn columns(&self) -> &[SqliteColumn] {
&self.columns
}
fn try_get_raw<I>(&self, index: I) -> Result<SqliteValueRef<'_>, Error>
where
I: ColumnIndex<Self>,
{
let index = index.index(self)?;
let values_ptr = self.values.load(Ordering::Acquire);
if !values_ptr.is_null() {
let values: &[SqliteValue] =
unsafe { slice::from_raw_parts(values_ptr, self.num_values) };
Ok(SqliteValueRef::value(&values[index]))
} else {
Ok(SqliteValueRef::statement(
&self.statement,
self.columns[index].type_info.clone(),
index,
))
}
}
}
impl Drop for SqliteRow {
fn drop(&mut self) {
let values_ptr = self.values.load(Ordering::Acquire);
if !values_ptr.is_null() {
let values: &mut [SqliteValue] =
unsafe { slice::from_raw_parts_mut(values_ptr, self.num_values) };
let _ = unsafe { Box::from_raw(values) };
}
}
}
impl ColumnIndex<SqliteRow> for &'_ str {
fn index(&self, row: &SqliteRow) -> Result<usize, Error> {
row.column_names
.get(*self)
.ok_or_else(|| Error::ColumnNotFound((*self).into()))
.map(|v| *v)
}
}
#[cfg(feature = "any")]
impl From<SqliteRow> for crate::any::AnyRow {
#[inline]
fn from(row: SqliteRow) -> Self {
crate::any::AnyRow {
columns: row.columns.iter().map(|col| col.clone().into()).collect(),
kind: crate::any::row::AnyRowKind::Sqlite(row),
}
}
}