use std::ffi::CStr;
use std::os::raw::c_char;
use std::time::Duration;
use crate::bindings;
use crate::connection::Connection;
use crate::error::{Error, Result};
use crate::format::InputFormat;
use crate::query_param::{EncodedParams, QueryParams};
use crate::query_result::QueryResult;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct WriteStats {
pub rows_written: u64,
pub bytes_written: u64,
pub elapsed: Duration,
}
#[derive(Debug)]
pub struct InsertStream<'a> {
handle: bindings::chdb_insert_stream,
_conn: &'a mut Connection,
done: bool,
pending: Vec<u8>,
write_buffer: usize,
}
pub const DEFAULT_WRITE_BUFFER: usize = 64 * 1024;
impl<'a> InsertStream<'a> {
pub(crate) fn start(conn: &'a mut Connection, sql: &str, format: InputFormat) -> Result<Self> {
let handle = {
let format = format.as_str();
unsafe {
bindings::chdb_stream_insert_n(
conn.handle(),
sql.as_ptr() as *const c_char,
sql.len(),
format.as_ptr() as *const c_char,
format.len(),
)
}
};
let stream = Self {
handle,
_conn: conn,
done: false,
pending: Vec::new(),
write_buffer: DEFAULT_WRITE_BUFFER,
};
stream.check_error()?;
Ok(stream)
}
pub(crate) fn start_with_params(
conn: &'a mut Connection,
sql: &str,
format: InputFormat,
params: impl Into<QueryParams>,
) -> Result<Self> {
let format = format.as_str();
let encoded = EncodedParams::encode(params)?;
let handle = {
unsafe {
bindings::chdb_stream_insert_with_params_n(
conn.handle(),
sql.as_ptr() as *const c_char,
sql.len(),
format.as_ptr() as *const c_char,
format.len(),
encoded.names_ptr(),
encoded.name_lens_ptr(),
encoded.values_ptr(),
encoded.value_lens_ptr(),
encoded.len(),
)
}
};
let stream = Self {
handle,
_conn: conn,
done: false,
pending: Vec::new(),
write_buffer: DEFAULT_WRITE_BUFFER,
};
stream.check_error()?;
Ok(stream)
}
fn check_error(&self) -> Result<()> {
let err = unsafe { bindings::chdb_stream_insert_error(self.handle) };
if err.is_null() {
return Ok(());
}
let detail = unsafe { CStr::from_ptr(err) }
.to_string_lossy()
.into_owned();
Err(Error::QueryError(detail))
}
pub fn with_write_buffer(mut self, bytes: usize) -> Self {
self.write_buffer = bytes;
self
}
pub fn append(&mut self, data: &[u8]) -> Result<()> {
self.flush_pending()?;
self.send(data)
}
fn flush_pending(&mut self) -> Result<()> {
if self.pending.is_empty() {
return Ok(());
}
let pending = std::mem::take(&mut self.pending);
let sent = self.send(&pending);
self.pending = pending;
self.pending.clear();
sent
}
fn send(&mut self, data: &[u8]) -> Result<()> {
let state = unsafe {
bindings::chdb_stream_append(
self.handle,
data.as_ptr() as *const std::ffi::c_void,
data.len(),
)
};
if state != bindings::chdb_state_CHDBSuccess {
self.check_error()?;
return Err(Error::EngineCallFailed {
call: "chdb_stream_append",
});
}
Ok(())
}
pub fn finish(mut self) -> Result<WriteStats> {
self.flush_pending()?;
self.done = true;
let result_ptr = unsafe { bindings::chdb_stream_done(self.handle) };
if result_ptr.is_null() {
self.check_error()?;
return Err(Error::NoResult);
}
let result = QueryResult::new(result_ptr).check_error()?;
Ok(WriteStats {
rows_written: result.rows_written(),
bytes_written: result.bytes_written(),
elapsed: result.elapsed(),
})
}
pub fn cancel(mut self) {
self.done = true;
unsafe { bindings::chdb_stream_cancel_insert(self.handle) };
}
}
impl Drop for InsertStream<'_> {
fn drop(&mut self) {
if !self.done {
unsafe { bindings::chdb_stream_cancel_insert(self.handle) };
}
unsafe { bindings::chdb_destroy_insert_stream(self.handle) };
}
}
impl std::io::Write for InsertStream<'_> {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
if self.pending.len() + buf.len() > self.write_buffer {
self.flush_pending().map_err(io_err)?;
}
if buf.len() >= self.write_buffer {
self.send(buf).map_err(io_err)?;
} else {
if self.pending.capacity() == 0 {
self.pending.reserve(self.write_buffer);
}
self.pending.extend_from_slice(buf);
}
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
self.flush_pending().map_err(io_err)
}
}
fn io_err(e: Error) -> std::io::Error {
std::io::Error::other(e.to_string())
}