use crate::cassandra::consistency::Consistency;
use crate::cassandra::custom_payload::CustomPayload;
use crate::cassandra::error::*;
use crate::cassandra::future::CassFuture;
use crate::cassandra::policy::retry::RetryPolicy;
use crate::cassandra::statement::Statement;
use crate::cassandra::util::{Protected, ProtectedInner, ProtectedWithSession};
use crate::cassandra_sys::cass_session_execute_batch;
use crate::{CassResult, Session};
use crate::cassandra_sys::cass_batch_add_statement;
use crate::cassandra_sys::cass_batch_free;
use crate::cassandra_sys::cass_batch_new;
use crate::cassandra_sys::cass_batch_set_consistency;
use crate::cassandra_sys::cass_batch_set_custom_payload;
use crate::cassandra_sys::cass_batch_set_retry_policy;
use crate::cassandra_sys::cass_batch_set_serial_consistency;
use crate::cassandra_sys::cass_batch_set_timestamp;
use crate::cassandra_sys::CassBatch as _Batch;
use crate::cassandra_sys::CassBatchType_;
#[derive(Debug)]
struct BatchInner(*mut _Batch);
#[derive(Debug)]
pub struct Batch(BatchInner, Session);
unsafe impl Send for BatchInner {}
unsafe impl Sync for BatchInner {}
impl ProtectedInner<*mut _Batch> for BatchInner {
#[inline(always)]
fn inner(&self) -> *mut _Batch {
self.0
}
}
impl Protected<*mut _Batch> for BatchInner {
#[inline(always)]
fn build(inner: *mut _Batch) -> Self {
if inner.is_null() {
panic!("Unexpected null pointer")
};
Self(inner)
}
}
impl ProtectedInner<*mut _Batch> for Batch {
#[inline(always)]
fn inner(&self) -> *mut _Batch {
self.0.inner()
}
}
impl ProtectedWithSession<*mut _Batch> for Batch {
#[inline(always)]
fn build(inner: *mut _Batch, session: Session) -> Self {
Self(BatchInner::build(inner), session)
}
#[inline(always)]
fn session(&self) -> &Session {
&self.1
}
}
impl Drop for BatchInner {
fn drop(&mut self) {
unsafe { cass_batch_free(self.0) }
}
}
impl Batch {
pub(crate) fn new(batch_type: BatchType, session: Session) -> Batch {
unsafe { Batch(BatchInner(cass_batch_new(batch_type.inner())), session) }
}
pub fn session(&self) -> &Session {
ProtectedWithSession::session(self)
}
pub async fn execute(self) -> Result<CassResult> {
let (batch, session) = (self.0, self.1);
let execute_future = {
let execute_batch =
unsafe { cass_session_execute_batch(session.inner(), batch.inner()) };
CassFuture::build(session, execute_batch)
};
execute_future.await
}
pub fn set_consistency(&mut self, consistency: Consistency) -> Result<&mut Self> {
unsafe { cass_batch_set_consistency(self.inner(), consistency.inner()).to_result(self) }
}
pub fn set_serial_consistency(&mut self, consistency: Consistency) -> Result<&mut Self> {
unsafe {
cass_batch_set_serial_consistency(self.inner(), consistency.inner()).to_result(self)
}
}
pub fn set_timestamp(&mut self, timestamp: i64) -> Result<&Self> {
unsafe { cass_batch_set_timestamp(self.inner(), timestamp).to_result(self) }
}
pub fn set_retry_policy(&mut self, retry_policy: RetryPolicy) -> Result<&mut Self> {
unsafe { cass_batch_set_retry_policy(self.inner(), retry_policy.inner()).to_result(self) }
}
pub fn set_custom_payload(&mut self, custom_payload: CustomPayload) -> Result<&mut Self> {
unsafe {
cass_batch_set_custom_payload(self.inner(), custom_payload.inner()).to_result(self)
}
}
pub fn add_statement(&mut self, statement: Statement) -> Result<&Self> {
if self.session() != statement.session() {
return Err(ErrorKind::BatchSessionMismatch(
self.session().clone(),
statement.session().clone(),
)
.into());
}
unsafe { cass_batch_add_statement(self.inner(), statement.inner()).to_result(self) }
}
}
#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
#[allow(missing_docs)] #[allow(non_camel_case_types)] pub enum BatchType {
LOGGED,
UNLOGGED,
COUNTER,
}
enhance_nullary_enum!(BatchType, CassBatchType_, {
(LOGGED, CASS_BATCH_TYPE_LOGGED, "LOGGED"),
(UNLOGGED, CASS_BATCH_TYPE_UNLOGGED, "UNLOGGED"),
(COUNTER, CASS_BATCH_TYPE_COUNTER, "COUNTER"),
});