use crate::cassandra_sys::CASS_ERROR_LIB_INVALID_DATA;
use bigdecimal::BigDecimal;
use crate::cassandra::collection::List;
use crate::cassandra::collection::Map;
use crate::cassandra::collection::Set;
use crate::cassandra::consistency::Consistency;
use crate::cassandra::custom_payload::CustomPayload;
use crate::cassandra::error::*;
use crate::cassandra::future::CassFuture;
use crate::cassandra::inet::Inet;
use crate::cassandra::policy::retry::RetryPolicy;
use crate::cassandra::result::CassResult;
use crate::cassandra::tuple::Tuple;
use crate::cassandra::user_type::UserType;
use crate::cassandra::util::{Protected, ProtectedInner, ProtectedWithSession};
use crate::cassandra::uuid::Uuid;
use crate::Session;
use crate::cassandra_sys::cass_false;
use crate::cassandra_sys::cass_session_execute;
use crate::cassandra_sys::cass_statement_add_key_index;
use crate::cassandra_sys::cass_statement_bind_bool;
use crate::cassandra_sys::cass_statement_bind_bool_by_name_n;
use crate::cassandra_sys::cass_statement_bind_bytes;
use crate::cassandra_sys::cass_statement_bind_bytes_by_name_n;
use crate::cassandra_sys::cass_statement_bind_collection;
use crate::cassandra_sys::cass_statement_bind_collection_by_name_n;
use crate::cassandra_sys::cass_statement_bind_decimal;
use crate::cassandra_sys::cass_statement_bind_decimal_by_name_n;
use crate::cassandra_sys::cass_statement_bind_double;
use crate::cassandra_sys::cass_statement_bind_double_by_name_n;
use crate::cassandra_sys::cass_statement_bind_float;
use crate::cassandra_sys::cass_statement_bind_float_by_name_n;
use crate::cassandra_sys::cass_statement_bind_inet;
use crate::cassandra_sys::cass_statement_bind_inet_by_name_n;
use crate::cassandra_sys::cass_statement_bind_int16;
use crate::cassandra_sys::cass_statement_bind_int16_by_name_n;
use crate::cassandra_sys::cass_statement_bind_int32;
use crate::cassandra_sys::cass_statement_bind_int32_by_name_n;
use crate::cassandra_sys::cass_statement_bind_int64;
use crate::cassandra_sys::cass_statement_bind_int64_by_name_n;
use crate::cassandra_sys::cass_statement_bind_int8;
use crate::cassandra_sys::cass_statement_bind_int8_by_name_n;
use crate::cassandra_sys::cass_statement_bind_null;
use crate::cassandra_sys::cass_statement_bind_null_by_name_n;
use crate::cassandra_sys::cass_statement_bind_string_by_name_n;
use crate::cassandra_sys::cass_statement_bind_string_n;
use crate::cassandra_sys::cass_statement_bind_tuple;
use crate::cassandra_sys::cass_statement_bind_tuple_by_name_n;
use crate::cassandra_sys::cass_statement_bind_uint32;
use crate::cassandra_sys::cass_statement_bind_uint32_by_name_n;
use crate::cassandra_sys::cass_statement_bind_user_type;
use crate::cassandra_sys::cass_statement_bind_user_type_by_name_n;
use crate::cassandra_sys::cass_statement_bind_uuid;
use crate::cassandra_sys::cass_statement_bind_uuid_by_name_n;
use crate::cassandra_sys::cass_statement_free;
use crate::cassandra_sys::cass_statement_new_n;
use crate::cassandra_sys::cass_statement_set_consistency;
use crate::cassandra_sys::cass_statement_set_custom_payload;
use crate::cassandra_sys::cass_statement_set_keyspace_n;
use crate::cassandra_sys::cass_statement_set_paging_size;
use crate::cassandra_sys::cass_statement_set_paging_state;
use crate::cassandra_sys::cass_statement_set_paging_state_token;
use crate::cassandra_sys::cass_statement_set_request_timeout;
use crate::cassandra_sys::cass_statement_set_retry_policy;
use crate::cassandra_sys::cass_statement_set_serial_consistency;
use crate::cassandra_sys::cass_statement_set_timestamp;
use crate::cassandra_sys::cass_statement_set_tracing;
use crate::cassandra_sys::cass_true;
use crate::cassandra_sys::CassStatement as _Statement;
use crate::cassandra_sys::CASS_UINT64_MAX;
use std::convert::TryInto;
use std::os::raw::c_char;
use std::time::Duration;
#[derive(Debug)]
struct StatementInner(*mut _Statement);
impl StatementInner {
fn new(query: &str, parameter_count: usize) -> Self {
let query_ptr = query.as_ptr() as *const c_char;
Self(unsafe { cass_statement_new_n(query_ptr, query.len(), parameter_count) })
}
}
#[derive(Debug)]
pub struct Statement(StatementInner, Session);
unsafe impl Send for StatementInner {}
unsafe impl Sync for StatementInner {}
impl ProtectedInner<*mut _Statement> for StatementInner {
#[inline(always)]
fn inner(&self) -> *mut _Statement {
self.0
}
}
impl Protected<*mut _Statement> for StatementInner {
#[inline(always)]
fn build(inner: *mut _Statement) -> Self {
if inner.is_null() {
panic!("Unexpected null pointer")
};
Self(inner)
}
}
impl ProtectedInner<*mut _Statement> for Statement {
#[inline(always)]
fn inner(&self) -> *mut _Statement {
self.0.inner()
}
}
impl ProtectedWithSession<*mut _Statement> for Statement {
#[inline(always)]
fn build(inner: *mut _Statement, session: Session) -> Self {
Statement(StatementInner::build(inner), session)
}
#[inline(always)]
fn session(&self) -> &Session {
&self.1
}
}
impl Drop for StatementInner {
fn drop(&mut self) {
unsafe { cass_statement_free(self.0) }
}
}
pub trait BindRustType<T> {
fn bind(&mut self, index: usize, value: T) -> Result<&mut Statement>;
fn bind_by_name(&mut self, col: &str, value: T) -> Result<&mut Statement>;
}
impl BindRustType<bool> for Statement {
fn bind(&mut self, index: usize, value: bool) -> Result<&mut Self> {
self.bind_bool(index, value)
}
fn bind_by_name(&mut self, col: &str, value: bool) -> Result<&mut Self> {
self.bind_bool_by_name(col, value)
}
}
impl BindRustType<f32> for Statement {
fn bind(&mut self, index: usize, value: f32) -> Result<&mut Self> {
self.bind_float(index, value)
}
fn bind_by_name(&mut self, col: &str, value: f32) -> Result<&mut Self> {
self.bind_float_by_name(col, value)
}
}
impl BindRustType<f64> for Statement {
fn bind(&mut self, index: usize, value: f64) -> Result<&mut Self> {
self.bind_double(index, value)
}
fn bind_by_name(&mut self, col: &str, value: f64) -> Result<&mut Self> {
self.bind_double_by_name(col, value)
}
}
impl BindRustType<i8> for Statement {
fn bind(&mut self, index: usize, value: i8) -> Result<&mut Self> {
self.bind_int8(index, value)
}
fn bind_by_name(&mut self, col: &str, value: i8) -> Result<&mut Self> {
self.bind_int8_by_name(col, value)
}
}
impl BindRustType<i16> for Statement {
fn bind(&mut self, index: usize, value: i16) -> Result<&mut Self> {
self.bind_int16(index, value)
}
fn bind_by_name(&mut self, col: &str, value: i16) -> Result<&mut Self> {
self.bind_int16_by_name(col, value)
}
}
impl BindRustType<i32> for Statement {
fn bind(&mut self, index: usize, value: i32) -> Result<&mut Self> {
self.bind_int32(index, value)
}
fn bind_by_name(&mut self, col: &str, value: i32) -> Result<&mut Self> {
self.bind_int32_by_name(col, value)
}
}
impl BindRustType<i64> for Statement {
fn bind(&mut self, index: usize, value: i64) -> Result<&mut Self> {
self.bind_int64(index, value)
}
fn bind_by_name(&mut self, col: &str, value: i64) -> Result<&mut Self> {
self.bind_int64_by_name(col, value)
}
}
impl BindRustType<u32> for Statement {
fn bind(&mut self, index: usize, value: u32) -> Result<&mut Self> {
self.bind_uint32(index, value)
}
fn bind_by_name(&mut self, col: &str, value: u32) -> Result<&mut Self> {
self.bind_uint32_by_name(col, value)
}
}
impl<'a> BindRustType<&'a str> for Statement {
fn bind(&mut self, index: usize, value: &str) -> Result<&mut Self> {
self.bind_string(index, value)
}
fn bind_by_name(&mut self, col: &str, value: &str) -> Result<&mut Self> {
self.bind_string_by_name(col, value)
}
}
impl BindRustType<Set> for Statement {
fn bind(&mut self, index: usize, value: Set) -> Result<&mut Self> {
self.bind_set(index, value)
}
fn bind_by_name(&mut self, col: &str, value: Set) -> Result<&mut Self> {
self.bind_set_by_name(col, value)
}
}
impl BindRustType<List> for Statement {
fn bind(&mut self, index: usize, value: List) -> Result<&mut Self> {
self.bind_list(index, value)
}
fn bind_by_name(&mut self, col: &str, value: List) -> Result<&mut Self> {
self.bind_list_by_name(col, value)
}
}
impl BindRustType<Uuid> for Statement {
fn bind(&mut self, index: usize, value: Uuid) -> Result<&mut Self> {
self.bind_uuid(index, value)
}
fn bind_by_name(&mut self, col: &str, value: Uuid) -> Result<&mut Self> {
self.bind_uuid_by_name(col, value)
}
}
impl BindRustType<uuid::Uuid> for Statement {
fn bind(&mut self, index: usize, value: uuid::Uuid) -> Result<&mut Self> {
self.bind_uuid(index, value.into())
}
fn bind_by_name(&mut self, col: &str, value: uuid::Uuid) -> Result<&mut Self> {
self.bind_uuid_by_name(col, value.into())
}
}
impl BindRustType<Inet> for Statement {
fn bind(&mut self, index: usize, value: Inet) -> Result<&mut Self> {
self.bind_inet(index, value)
}
fn bind_by_name(&mut self, col: &str, value: Inet) -> Result<&mut Self> {
self.bind_inet_by_name(col, value)
}
}
impl BindRustType<Map> for Statement {
fn bind(&mut self, index: usize, value: Map) -> Result<&mut Self> {
self.bind_map(index, value)
}
fn bind_by_name(&mut self, col: &str, value: Map) -> Result<&mut Self> {
self.bind_map_by_name(col, value)
}
}
impl BindRustType<Tuple> for Statement {
fn bind(&mut self, index: usize, value: Tuple) -> Result<&mut Self> {
self.bind_tuple(index, value)
}
fn bind_by_name(&mut self, col: &str, value: Tuple) -> Result<&mut Self> {
self.bind_tuple_by_name(col, value)
}
}
impl BindRustType<&UserType> for Statement {
fn bind(&mut self, index: usize, value: &UserType) -> Result<&mut Self> {
self.bind_user_type(index, value)
}
fn bind_by_name(&mut self, col: &str, value: &UserType) -> Result<&mut Self> {
self.bind_user_type_by_name(col, value)
}
}
impl BindRustType<Vec<u8>> for Statement {
fn bind(&mut self, index: usize, value: Vec<u8>) -> Result<&mut Self> {
self.bind_bytes(index, value)
}
fn bind_by_name(&mut self, col: &str, value: Vec<u8>) -> Result<&mut Self> {
self.bind_bytes_by_name(col, value)
}
}
impl BindRustType<&BigDecimal> for Statement {
fn bind(&mut self, index: usize, value: &BigDecimal) -> Result<&mut Self> {
self.bind_decimal(index, value)
}
fn bind_by_name(&mut self, col: &str, value: &BigDecimal) -> Result<&mut Self> {
self.bind_decimal_by_name(col, value)
}
}
impl Statement {
pub(crate) fn new(session: Session, query: &str, parameter_count: usize) -> Self {
Statement(StatementInner::new(query, parameter_count), session)
}
pub fn session(&self) -> &Session {
ProtectedWithSession::session(self)
}
pub async fn execute(self) -> Result<CassResult> {
let (statement, session) = (self.0, self.1);
let fut = {
let execute = unsafe { cass_session_execute(session.inner(), statement.inner()) };
<CassFuture<CassResult>>::build(session, execute)
};
fut.await
}
pub fn add_key_index(&mut self, index: usize) -> Result<&mut Self> {
unsafe { cass_statement_add_key_index(self.inner(), index).to_result(self) }
}
pub fn set_keyspace(&mut self, keyspace: String) -> Result<&mut Self> {
unsafe {
let keyspace_ptr = keyspace.as_ptr() as *const c_char;
cass_statement_set_keyspace_n(self.inner(), keyspace_ptr, keyspace.len())
.to_result(self)
}
}
pub fn set_consistency(&mut self, consistency: Consistency) -> Result<&mut Self> {
unsafe { cass_statement_set_consistency(self.inner(), consistency.inner()).to_result(self) }
}
pub fn set_serial_consistency(&mut self, serial_consistency: Consistency) -> Result<&mut Self> {
unsafe {
cass_statement_set_serial_consistency(self.inner(), serial_consistency.inner())
.to_result(self)
}
}
pub fn set_paging_size(&mut self, page_size: i32) -> Result<&mut Self> {
unsafe { cass_statement_set_paging_size(self.inner(), page_size).to_result(self) }
}
pub fn set_paging_state(&mut self, result: CassResult) -> Result<&mut Self> {
unsafe { cass_statement_set_paging_state(self.inner(), result.inner()).to_result(self) }
}
pub fn set_paging_state_token(&mut self, paging_state: &[u8]) -> Result<&mut Self> {
unsafe {
cass_statement_set_paging_state_token(
self.inner(),
paging_state.as_ptr() as *const c_char,
paging_state.len(),
)
.to_result(self)
}
}
pub fn set_timestamp(&mut self, timestamp: i64) -> Result<&mut Self> {
unsafe { cass_statement_set_timestamp(self.inner(), timestamp).to_result(self) }
}
pub fn set_statement_request_timeout(&mut self, timeout: Option<Duration>) -> &mut Self {
unsafe {
let timeout_millis = match timeout {
None => CASS_UINT64_MAX as u64,
Some(time) => time.as_millis() as u64,
};
cass_statement_set_request_timeout(self.inner(), timeout_millis);
}
self
}
pub fn set_retry_policy(&mut self, retry_policy: RetryPolicy) -> Result<&mut Self> {
unsafe {
cass_statement_set_retry_policy(self.inner(), retry_policy.inner()).to_result(self)
}
}
pub fn set_custom_payload(&mut self, payload: CustomPayload) -> Result<&mut Self> {
unsafe { cass_statement_set_custom_payload(self.inner(), payload.inner()).to_result(self) }
}
pub fn set_tracing(&mut self, value: bool) -> Result<&mut Self> {
unsafe {
cass_statement_set_tracing(self.inner(), if value { cass_true } else { cass_false })
.to_result(self)
}
}
pub fn bind_null(&mut self, index: usize) -> Result<&mut Self> {
unsafe { cass_statement_bind_null(self.inner(), index).to_result(self) }
}
pub fn bind_null_by_name(&mut self, name: &str) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_null_by_name_n(self.inner(), name_ptr, name.len()).to_result(self)
}
}
pub fn bind_int8(&mut self, index: usize, value: i8) -> Result<&mut Self> {
unsafe { cass_statement_bind_int8(self.inner(), index, value).to_result(self) }
}
pub fn bind_int8_by_name(&mut self, name: &str, value: i8) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_int8_by_name_n(self.inner(), name_ptr, name.len(), value)
.to_result(self)
}
}
pub fn bind_int16(&mut self, index: usize, value: i16) -> Result<&mut Self> {
unsafe { cass_statement_bind_int16(self.inner(), index, value).to_result(self) }
}
pub fn bind_int16_by_name(&mut self, name: &str, value: i16) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_int16_by_name_n(self.inner(), name_ptr, name.len(), value)
.to_result(self)
}
}
pub fn bind_int32(&mut self, index: usize, value: i32) -> Result<&mut Self> {
unsafe { cass_statement_bind_int32(self.inner(), index, value).to_result(self) }
}
pub fn bind_int32_by_name(&mut self, name: &str, value: i32) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_int32_by_name_n(self.inner(), name_ptr, name.len(), value)
.to_result(self)
}
}
pub fn bind_uint32(&mut self, index: usize, value: u32) -> Result<&mut Self> {
unsafe { cass_statement_bind_uint32(self.inner(), index, value).to_result(self) }
}
pub fn bind_uint32_by_name(&mut self, name: &str, value: u32) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_uint32_by_name_n(self.inner(), name_ptr, name.len(), value)
.to_result(self)
}
}
pub fn bind_int64(&mut self, index: usize, value: i64) -> Result<&mut Self> {
unsafe { cass_statement_bind_int64(self.inner(), index, value).to_result(self) }
}
pub fn bind_int64_by_name(&mut self, name: &str, value: i64) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_int64_by_name_n(self.inner(), name_ptr, name.len(), value)
.to_result(self)
}
}
pub fn bind_float(&mut self, index: usize, value: f32) -> Result<&mut Self> {
unsafe { cass_statement_bind_float(self.inner(), index, value).to_result(self) }
}
pub fn bind_float_by_name(&mut self, name: &str, value: f32) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_float_by_name_n(self.inner(), name_ptr, name.len(), value)
.to_result(self)
}
}
pub fn bind_double(&mut self, index: usize, value: f64) -> Result<&mut Self> {
unsafe { cass_statement_bind_double(self.inner(), index, value).to_result(self) }
}
pub fn bind_double_by_name(&mut self, name: &str, value: f64) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_double_by_name_n(self.inner(), name_ptr, name.len(), value)
.to_result(self)
}
}
pub fn bind_bool(&mut self, index: usize, value: bool) -> Result<&mut Self> {
unsafe {
cass_statement_bind_bool(
self.inner(),
index,
if value { cass_true } else { cass_false },
)
.to_result(self)
}
}
pub fn bind_bool_by_name(&mut self, name: &str, value: bool) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_bool_by_name_n(
self.inner(),
name_ptr,
name.len(),
if value { cass_true } else { cass_false },
)
.to_result(self)
}
}
pub fn bind_string(&mut self, index: usize, value: &str) -> Result<&mut Self> {
unsafe {
let value_ptr = value.as_ptr() as *const c_char;
cass_statement_bind_string_n(self.inner(), index, value_ptr, value.len())
.to_result(self)
}
}
pub fn bind_string_by_name(&mut self, name: &str, value: &str) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
let value_cstr = std::ffi::CString::new(value)?;
cass_statement_bind_string_by_name_n(
self.inner(),
name_ptr,
name.len(),
value_cstr.as_ptr(),
value.len(),
)
.to_result(self)
}
}
pub fn bind_bytes(&mut self, index: usize, value: Vec<u8>) -> Result<&mut Self> {
unsafe {
cass_statement_bind_bytes(self.inner(), index, value.as_ptr(), value.len())
.to_result(self)
}
}
pub fn bind_bytes_by_name(&mut self, name: &str, mut value: Vec<u8>) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_bytes_by_name_n(
self.inner(),
name_ptr,
name.len(),
value.as_mut_ptr(),
value.len(),
)
.to_result(self)
}
}
pub fn bind_uuid(&mut self, index: usize, value: Uuid) -> Result<&mut Self> {
unsafe { cass_statement_bind_uuid(self.inner(), index, value.inner()).to_result(self) }
}
pub fn bind_uuid_by_name(&mut self, name: &str, value: Uuid) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_uuid_by_name_n(self.inner(), name_ptr, name.len(), value.inner())
.to_result(self)
}
}
pub fn bind_inet(&mut self, index: usize, value: Inet) -> Result<&mut Self> {
unsafe { cass_statement_bind_inet(self.inner(), index, value.inner()).to_result(self) }
}
pub fn bind_inet_by_name(&mut self, name: &str, value: Inet) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_inet_by_name_n(self.inner(), name_ptr, name.len(), value.inner())
.to_result(self)
}
}
pub fn bind_decimal(&mut self, index: usize, value: &BigDecimal) -> Result<&mut Self> {
let dec_parts = value.as_bigint_and_exponent();
let varint = dec_parts.0.to_signed_bytes_be();
let scale: i32 = match dec_parts.1.try_into() {
Ok(s) => s,
Err(_) => {
return Err(CASS_ERROR_LIB_INVALID_DATA.to_error());
}
};
unsafe {
cass_statement_bind_decimal(self.inner(), index, varint.as_ptr(), varint.len(), scale)
.to_result(self)
}
}
pub fn bind_decimal_by_name(&mut self, name: &str, value: &BigDecimal) -> Result<&mut Self> {
let dec_parts = value.as_bigint_and_exponent();
let varint = dec_parts.0.to_signed_bytes_be();
let scale: i32 = match dec_parts.1.try_into() {
Ok(s) => s,
Err(_) => {
return Err(CASS_ERROR_LIB_INVALID_DATA.to_error());
}
};
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_decimal_by_name_n(
self.inner(),
name_ptr,
name.len(),
varint.as_ptr(),
varint.len(),
scale,
)
.to_result(self)
}
}
pub fn bind_map(&mut self, index: usize, map: Map) -> Result<&mut Self> {
unsafe { cass_statement_bind_collection(self.inner(), index, map.inner()).to_result(self) }
}
pub fn bind_map_by_name(&mut self, name: &str, map: Map) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_collection_by_name_n(
self.inner(),
name_ptr,
name.len(),
map.inner(),
)
.to_result(self)
}
}
pub fn bind_set(&mut self, index: usize, collection: Set) -> Result<&mut Self> {
unsafe {
cass_statement_bind_collection(self.inner(), index, collection.inner()).to_result(self)
}
}
pub fn bind_set_by_name(&mut self, name: &str, collection: Set) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_collection_by_name_n(
self.inner(),
name_ptr,
name.len(),
collection.inner(),
)
.to_result(self)
}
}
pub fn bind_list(&mut self, index: usize, collection: List) -> Result<&mut Self> {
unsafe {
cass_statement_bind_collection(self.inner(), index, collection.inner()).to_result(self)
}
}
pub fn bind_list_by_name(&mut self, name: &str, collection: List) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_collection_by_name_n(
self.inner(),
name_ptr,
name.len(),
collection.inner(),
)
.to_result(self)
}
}
pub fn bind_tuple(&mut self, index: usize, value: Tuple) -> Result<&mut Self> {
unsafe { cass_statement_bind_tuple(self.inner(), index, value.inner()).to_result(self) }
}
pub fn bind_tuple_by_name(&mut self, name: &str, value: Tuple) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_tuple_by_name_n(self.inner(), name_ptr, name.len(), value.inner())
.to_result(self)
}
}
pub fn bind_user_type(&mut self, index: usize, value: &UserType) -> Result<&mut Self> {
unsafe { cass_statement_bind_user_type(self.inner(), index, value.inner()).to_result(self) }
}
pub fn bind_user_type_by_name(&mut self, name: &str, value: &UserType) -> Result<&mut Self> {
unsafe {
let name_ptr = name.as_ptr() as *const c_char;
cass_statement_bind_user_type_by_name_n(
self.inner(),
name_ptr,
name.len(),
value.inner(),
)
.to_result(self)
}
}
}