|
|
|
@ -1,144 +1,20 @@
|
|
|
|
|
#[cxx::bridge]
|
|
|
|
|
mod ffi {
|
|
|
|
|
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
|
|
|
|
|
pub enum StatusBridgeCode {
|
|
|
|
|
OK = 0,
|
|
|
|
|
LOCK_ERROR = 1,
|
|
|
|
|
EXISTING_ERROR = 2,
|
|
|
|
|
NOT_FOUND_ERROR = 3,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
|
|
|
|
|
pub struct BridgeStatus {
|
|
|
|
|
pub code: StatusCode,
|
|
|
|
|
pub subcode: StatusSubCode,
|
|
|
|
|
pub severity: StatusSeverity,
|
|
|
|
|
pub bridge_code: StatusBridgeCode,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
|
|
|
|
|
pub enum StatusCode {
|
|
|
|
|
kOk = 0,
|
|
|
|
|
kNotFound = 1,
|
|
|
|
|
kCorruption = 2,
|
|
|
|
|
kNotSupported = 3,
|
|
|
|
|
kInvalidArgument = 4,
|
|
|
|
|
kIOError = 5,
|
|
|
|
|
kMergeInProgress = 6,
|
|
|
|
|
kIncomplete = 7,
|
|
|
|
|
kShutdownInProgress = 8,
|
|
|
|
|
kTimedOut = 9,
|
|
|
|
|
kAborted = 10,
|
|
|
|
|
kBusy = 11,
|
|
|
|
|
kExpired = 12,
|
|
|
|
|
kTryAgain = 13,
|
|
|
|
|
kCompactionTooLarge = 14,
|
|
|
|
|
kColumnFamilyDropped = 15,
|
|
|
|
|
kMaxCode,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
|
|
|
|
|
pub enum StatusSubCode {
|
|
|
|
|
kNone = 0,
|
|
|
|
|
kMutexTimeout = 1,
|
|
|
|
|
kLockTimeout = 2,
|
|
|
|
|
kLockLimit = 3,
|
|
|
|
|
kNoSpace = 4,
|
|
|
|
|
kDeadlock = 5,
|
|
|
|
|
kStaleFile = 6,
|
|
|
|
|
kMemoryLimit = 7,
|
|
|
|
|
kSpaceLimit = 8,
|
|
|
|
|
kPathNotFound = 9,
|
|
|
|
|
KMergeOperandsInsufficientCapacity = 10,
|
|
|
|
|
kManualCompactionPaused = 11,
|
|
|
|
|
kOverwritten = 12,
|
|
|
|
|
kTxnNotPrepared = 13,
|
|
|
|
|
kIOFenced = 14,
|
|
|
|
|
kMaxSubCode,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
|
|
|
|
|
pub enum StatusSeverity {
|
|
|
|
|
kNoError = 0,
|
|
|
|
|
kSoftError = 1,
|
|
|
|
|
kHardError = 2,
|
|
|
|
|
kFatalError = 3,
|
|
|
|
|
kUnrecoverableError = 4,
|
|
|
|
|
kMaxSeverity,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsafe extern "C++" {
|
|
|
|
|
include!("cozorocks.h");
|
|
|
|
|
|
|
|
|
|
type StatusCode;
|
|
|
|
|
type StatusSubCode;
|
|
|
|
|
type StatusSeverity;
|
|
|
|
|
|
|
|
|
|
type PinnableSliceBridge;
|
|
|
|
|
fn as_bytes(self: &PinnableSliceBridge) -> &[u8];
|
|
|
|
|
|
|
|
|
|
type SliceBridge;
|
|
|
|
|
fn as_bytes(self: &SliceBridge) -> &[u8];
|
|
|
|
|
|
|
|
|
|
type ReadOptionsBridge;
|
|
|
|
|
fn new_read_options() -> UniquePtr<ReadOptionsBridge>;
|
|
|
|
|
fn do_set_verify_checksums(self: &ReadOptionsBridge, v: bool);
|
|
|
|
|
fn do_set_total_order_seek(self: &ReadOptionsBridge, v: bool);
|
|
|
|
|
|
|
|
|
|
type WriteOptionsBridge;
|
|
|
|
|
fn new_write_options() -> UniquePtr<WriteOptionsBridge>;
|
|
|
|
|
fn do_set_disable_wal(self: &WriteOptionsBridge, v: bool);
|
|
|
|
|
|
|
|
|
|
type OptionsBridge;
|
|
|
|
|
fn new_options() -> UniquePtr<OptionsBridge>;
|
|
|
|
|
fn do_prepare_for_bulk_load(self: &OptionsBridge);
|
|
|
|
|
fn do_increase_parallelism(self: &OptionsBridge);
|
|
|
|
|
fn do_optimize_level_style_compaction(self: &OptionsBridge);
|
|
|
|
|
fn do_set_create_if_missing(self: &OptionsBridge, v: bool);
|
|
|
|
|
fn do_set_comparator(self: &OptionsBridge, name: &str, compare: fn(&[u8], &[u8]) -> i8);
|
|
|
|
|
|
|
|
|
|
pub type ColumnFamilyHandle;
|
|
|
|
|
type DBBridge;
|
|
|
|
|
fn open_db_raw(options: &OptionsBridge, path: &CxxString, status: &mut BridgeStatus) -> UniquePtr<DBBridge>;
|
|
|
|
|
fn get_cf_handle_raw(self: &DBBridge, name: &CxxString) -> SharedPtr<ColumnFamilyHandle>;
|
|
|
|
|
fn write_raw(self: &DBBridge, options: &WriteOptionsBridge, updates: Pin<&mut WriteBatchBridge>, status: &mut BridgeStatus);
|
|
|
|
|
fn put_raw(self: &DBBridge, options: &WriteOptionsBridge, cf: &ColumnFamilyHandle, key: &[u8], val: &[u8], status: &mut BridgeStatus);
|
|
|
|
|
fn delete_raw(self: &DBBridge, options: &WriteOptionsBridge, cf: &ColumnFamilyHandle, key: &[u8], status: &mut BridgeStatus);
|
|
|
|
|
fn get_raw(self: &DBBridge, options: &ReadOptionsBridge, cf: &ColumnFamilyHandle, key: &[u8], status: &mut BridgeStatus) -> UniquePtr<PinnableSliceBridge>;
|
|
|
|
|
fn iterator_raw(self: &DBBridge, options: &ReadOptionsBridge, cf: &ColumnFamilyHandle) -> UniquePtr<IteratorBridge>;
|
|
|
|
|
fn create_column_family_raw(self: &DBBridge, options: &OptionsBridge, name: &CxxString, status: &mut BridgeStatus);
|
|
|
|
|
fn drop_column_family_raw(self: &DBBridge, name: &CxxString, status: &mut BridgeStatus);
|
|
|
|
|
fn get_column_family_names_raw(self: &DBBridge) -> UniquePtr<CxxVector<CxxString>>;
|
|
|
|
|
|
|
|
|
|
pub type IteratorBridge;
|
|
|
|
|
fn seek_to_first(self: &IteratorBridge);
|
|
|
|
|
fn seek_to_last(self: &IteratorBridge);
|
|
|
|
|
fn next(self: &IteratorBridge);
|
|
|
|
|
fn is_valid(self: &IteratorBridge) -> bool;
|
|
|
|
|
fn do_seek(self: &IteratorBridge, key: &[u8]);
|
|
|
|
|
fn do_seek_for_prev(self: &IteratorBridge, key: &[u8]);
|
|
|
|
|
fn key_raw(self: &IteratorBridge) -> UniquePtr<SliceBridge>;
|
|
|
|
|
fn value_raw(self: &IteratorBridge) -> UniquePtr<SliceBridge>;
|
|
|
|
|
fn status(self: &IteratorBridge) -> BridgeStatus;
|
|
|
|
|
|
|
|
|
|
pub type WriteBatchBridge;
|
|
|
|
|
fn new_write_batch_raw() -> UniquePtr<WriteBatchBridge>;
|
|
|
|
|
fn batch_put_raw(self: &WriteBatchBridge, cf: &ColumnFamilyHandle, key: &[u8], val: &[u8], status: &mut BridgeStatus);
|
|
|
|
|
fn batch_delete_raw(self: &WriteBatchBridge, cf: &ColumnFamilyHandle, key: &[u8], status: &mut BridgeStatus);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
use std::fmt::Formatter;
|
|
|
|
|
mod bridge;
|
|
|
|
|
|
|
|
|
|
use bridge::*;
|
|
|
|
|
|
|
|
|
|
use std::fmt::{Display, Formatter};
|
|
|
|
|
use std::fmt::Debug;
|
|
|
|
|
use std::path::Path;
|
|
|
|
|
use cxx::{UniquePtr, SharedPtr, let_cxx_string};
|
|
|
|
|
pub use ffi::BridgeStatus;
|
|
|
|
|
pub use ffi::StatusBridgeCode;
|
|
|
|
|
pub use ffi::StatusCode;
|
|
|
|
|
pub use ffi::StatusSubCode;
|
|
|
|
|
pub use ffi::StatusSeverity;
|
|
|
|
|
pub use ffi::IteratorBridge;
|
|
|
|
|
use ffi::*;
|
|
|
|
|
use std::ops::{Deref, DerefMut};
|
|
|
|
|
use cxx::{let_cxx_string};
|
|
|
|
|
pub use cxx::{UniquePtr, SharedPtr};
|
|
|
|
|
pub use bridge::BridgeStatus;
|
|
|
|
|
pub use bridge::StatusBridgeCode;
|
|
|
|
|
pub use bridge::StatusCode;
|
|
|
|
|
pub use bridge::StatusSubCode;
|
|
|
|
|
pub use bridge::StatusSeverity;
|
|
|
|
|
pub use bridge::Slice;
|
|
|
|
|
pub use bridge::PinnableSlice;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
impl std::fmt::Display for BridgeStatus {
|
|
|
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
|
|
@ -146,344 +22,486 @@ impl std::fmt::Display for BridgeStatus {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl std::error::Error for BridgeStatus {}
|
|
|
|
|
|
|
|
|
|
type Result<T> = std::result::Result<T, BridgeStatus>;
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
|
pub struct BridgeError {
|
|
|
|
|
pub status: BridgeStatus,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub type Options = UniquePtr<OptionsBridge>;
|
|
|
|
|
impl Display for BridgeError {
|
|
|
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
|
|
|
Debug::fmt(self, f)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type ColumnFamilyHandle = SharedPtr<ffi::ColumnFamilyHandle>;
|
|
|
|
|
impl std::error::Error for BridgeError {}
|
|
|
|
|
|
|
|
|
|
pub trait OptionsTrait {
|
|
|
|
|
fn prepare_for_bulk_load(self) -> Self;
|
|
|
|
|
fn increase_parallelism(self) -> Self;
|
|
|
|
|
fn optimize_level_style_compaction(self) -> Self;
|
|
|
|
|
fn set_create_if_missing(self, v: bool) -> Self;
|
|
|
|
|
fn set_comparator(self, name: &str, compare: fn(&[u8], &[u8]) -> i8) -> Self;
|
|
|
|
|
fn default() -> Self;
|
|
|
|
|
impl Default for BridgeStatus {
|
|
|
|
|
fn default() -> Self {
|
|
|
|
|
BridgeStatus {
|
|
|
|
|
code: StatusCode::kOk,
|
|
|
|
|
subcode: StatusSubCode::kNone,
|
|
|
|
|
severity: StatusSeverity::kNoError,
|
|
|
|
|
bridge_code: StatusBridgeCode::OK,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl OptionsTrait for Options {
|
|
|
|
|
#[inline]
|
|
|
|
|
fn prepare_for_bulk_load(self) -> Self {
|
|
|
|
|
self.do_prepare_for_bulk_load();
|
|
|
|
|
self
|
|
|
|
|
impl BridgeStatus {
|
|
|
|
|
fn check_err<T>(self, data: T) -> Result<T> {
|
|
|
|
|
let err: Option<BridgeError> = self.into();
|
|
|
|
|
match err {
|
|
|
|
|
Some(e) => Err(e),
|
|
|
|
|
None => Ok(data)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn increase_parallelism(self) -> Self {
|
|
|
|
|
self.do_increase_parallelism();
|
|
|
|
|
self
|
|
|
|
|
impl From<BridgeStatus> for Option<BridgeError> {
|
|
|
|
|
fn from(s: BridgeStatus) -> Self {
|
|
|
|
|
if s.severity == StatusSeverity::kNoError && s.bridge_code == StatusBridgeCode::OK {
|
|
|
|
|
None
|
|
|
|
|
} else {
|
|
|
|
|
Some(BridgeError { status: s })
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn optimize_level_style_compaction(self) -> Self {
|
|
|
|
|
self.do_optimize_level_style_compaction();
|
|
|
|
|
self
|
|
|
|
|
pub type Result<T> = std::result::Result<T, BridgeError>;
|
|
|
|
|
|
|
|
|
|
pub trait SlicePtr {
|
|
|
|
|
fn as_bytes(&self) -> &[u8];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl SlicePtr for UniquePtr<Slice> {
|
|
|
|
|
fn as_bytes(&self) -> &[u8] {
|
|
|
|
|
convert_slice_back(self)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn set_create_if_missing(self, v: bool) -> Self {
|
|
|
|
|
self.do_set_create_if_missing(v);
|
|
|
|
|
self
|
|
|
|
|
impl SlicePtr for UniquePtr<PinnableSlice> {
|
|
|
|
|
fn as_bytes(&self) -> &[u8] {
|
|
|
|
|
convert_pinnable_slice_back(self)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn set_comparator(self, name: &str, compare: fn(&[u8], &[u8]) -> i8) -> Self {
|
|
|
|
|
self.do_set_comparator(name, compare);
|
|
|
|
|
self
|
|
|
|
|
pub struct RustComparatorPtr(UniquePtr<RustComparator>);
|
|
|
|
|
|
|
|
|
|
impl RustComparatorPtr {
|
|
|
|
|
pub fn new(name: &str, cmp: fn(&[u8], &[u8]) -> i8) -> Self {
|
|
|
|
|
Self(new_rust_comparator(name, cmp))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn default() -> Self {
|
|
|
|
|
new_options()
|
|
|
|
|
impl Deref for RustComparatorPtr {
|
|
|
|
|
type Target = UniquePtr<RustComparator>;
|
|
|
|
|
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub type ReadOptions = UniquePtr<ReadOptionsBridge>;
|
|
|
|
|
pub struct OptionsPtr(UniquePtr<Options>);
|
|
|
|
|
|
|
|
|
|
pub trait ReadOptionsTrait {
|
|
|
|
|
fn set_total_order_seek(self, v: bool) -> Self;
|
|
|
|
|
fn set_verify_checksums(self, v: bool) -> Self;
|
|
|
|
|
fn default() -> Self;
|
|
|
|
|
impl Deref for OptionsPtr {
|
|
|
|
|
type Target = UniquePtr<Options>;
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl DerefMut for OptionsPtr {
|
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl ReadOptionsTrait for ReadOptions {
|
|
|
|
|
fn set_total_order_seek(self, v: bool) -> Self {
|
|
|
|
|
self.do_set_total_order_seek(v);
|
|
|
|
|
impl OptionsPtr {
|
|
|
|
|
pub fn default() -> Self {
|
|
|
|
|
Self(new_options())
|
|
|
|
|
}
|
|
|
|
|
pub fn prepare_for_bulk_load(&mut self) -> &mut Self {
|
|
|
|
|
prepare_for_bulk_load(self.pin_mut());
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
fn set_verify_checksums(self, v: bool) -> Self {
|
|
|
|
|
self.do_set_verify_checksums(v);
|
|
|
|
|
pub fn increase_parallelism(&mut self) -> &mut Self {
|
|
|
|
|
increase_parallelism(self.pin_mut());
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn default() -> Self {
|
|
|
|
|
new_read_options()
|
|
|
|
|
pub fn optimize_level_style_compaction(&mut self) -> &mut Self {
|
|
|
|
|
optimize_level_style_compaction(self.pin_mut());
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
pub fn set_create_if_missing(&mut self, v: bool) -> &mut Self {
|
|
|
|
|
set_create_if_missing(self.pin_mut(), v);
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
pub fn set_comparator(&mut self, cmp: &RustComparatorPtr) -> &mut Self {
|
|
|
|
|
set_comparator(self.pin_mut(), cmp);
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub type WriteOptions = UniquePtr<WriteOptionsBridge>;
|
|
|
|
|
|
|
|
|
|
pub trait WriteOptionsTrait {
|
|
|
|
|
fn set_disable_wal(self, v: bool) -> Self;
|
|
|
|
|
fn default() -> Self;
|
|
|
|
|
pub struct ReadOptionsPtr(UniquePtr<ReadOptions>);
|
|
|
|
|
|
|
|
|
|
impl Deref for ReadOptionsPtr {
|
|
|
|
|
type Target = UniquePtr<ReadOptions>;
|
|
|
|
|
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl WriteOptionsTrait for WriteOptions {
|
|
|
|
|
#[inline]
|
|
|
|
|
fn set_disable_wal(self, v: bool) -> Self {
|
|
|
|
|
self.do_set_disable_wal(v);
|
|
|
|
|
impl DerefMut for ReadOptionsPtr {
|
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
impl ReadOptionsPtr {
|
|
|
|
|
pub fn default() -> Self {
|
|
|
|
|
Self(new_read_options())
|
|
|
|
|
}
|
|
|
|
|
pub fn set_verify_checksums(&mut self, v: bool) -> &mut Self {
|
|
|
|
|
set_verify_checksums(self.pin_mut(), v);
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
fn default() -> Self {
|
|
|
|
|
new_write_options()
|
|
|
|
|
pub fn set_total_order_seek(&mut self, v: bool) -> &mut Self {
|
|
|
|
|
set_total_order_seek(self.pin_mut(), v);
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct PinnableSlice(UniquePtr<PinnableSliceBridge>);
|
|
|
|
|
pub struct WriteOptionsPtr(UniquePtr<WriteOptions>);
|
|
|
|
|
|
|
|
|
|
impl AsRef<[u8]> for PinnableSlice {
|
|
|
|
|
#[inline]
|
|
|
|
|
fn as_ref(&self) -> &[u8] {
|
|
|
|
|
self.0.as_bytes()
|
|
|
|
|
impl Deref for WriteOptionsPtr {
|
|
|
|
|
type Target = UniquePtr<WriteOptions>;
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct Slice(UniquePtr<SliceBridge>);
|
|
|
|
|
impl DerefMut for WriteOptionsPtr {
|
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl AsRef<[u8]> for Slice {
|
|
|
|
|
#[inline]
|
|
|
|
|
fn as_ref(&self) -> &[u8] {
|
|
|
|
|
self.0.as_bytes()
|
|
|
|
|
impl WriteOptionsPtr {
|
|
|
|
|
pub fn default() -> Self {
|
|
|
|
|
Self(new_write_options())
|
|
|
|
|
}
|
|
|
|
|
pub fn set_disable_wal(&mut self, v: bool) -> &mut Self {
|
|
|
|
|
set_disable_wal(self.pin_mut(), v);
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct TransactionOptionsPtr(UniquePtr<TransactionOptions>);
|
|
|
|
|
|
|
|
|
|
pub type DBIterator = UniquePtr<IteratorBridge>;
|
|
|
|
|
impl Deref for TransactionOptionsPtr {
|
|
|
|
|
type Target = UniquePtr<TransactionOptions>;
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub trait IteratorImpl {
|
|
|
|
|
fn seek(&self, key: impl AsRef<[u8]>);
|
|
|
|
|
fn seek_for_prev(&self, key: impl AsRef<[u8]>);
|
|
|
|
|
fn key(&self) -> Slice;
|
|
|
|
|
fn value(&self) -> Slice;
|
|
|
|
|
impl DerefMut for TransactionOptionsPtr {
|
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl IteratorImpl for IteratorBridge {
|
|
|
|
|
#[inline]
|
|
|
|
|
fn seek(&self, key: impl AsRef<[u8]>) {
|
|
|
|
|
self.do_seek(key.as_ref());
|
|
|
|
|
impl TransactionOptionsPtr {
|
|
|
|
|
pub fn default() -> Self {
|
|
|
|
|
Self(new_transaction_options())
|
|
|
|
|
}
|
|
|
|
|
#[inline]
|
|
|
|
|
fn seek_for_prev(&self, key: impl AsRef<[u8]>) {
|
|
|
|
|
self.do_seek_for_prev(key.as_ref())
|
|
|
|
|
pub fn set_deadlock_detect(&mut self, v: bool) -> &mut Self {
|
|
|
|
|
set_deadlock_detect(self.pin_mut(), v);
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
#[inline]
|
|
|
|
|
fn key(&self) -> Slice {
|
|
|
|
|
Slice(self.key_raw())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct OptimisticTransactionOptionsPtr(UniquePtr<OptimisticTransactionOptions>);
|
|
|
|
|
|
|
|
|
|
impl Deref for OptimisticTransactionOptionsPtr {
|
|
|
|
|
type Target = UniquePtr<OptimisticTransactionOptions>;
|
|
|
|
|
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
#[inline]
|
|
|
|
|
fn value(&self) -> Slice {
|
|
|
|
|
Slice(self.value_raw())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl DerefMut for OptimisticTransactionOptionsPtr {
|
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn get_path_bytes(path: &std::path::Path) -> Vec<u8> {
|
|
|
|
|
#[cfg(unix)]
|
|
|
|
|
{
|
|
|
|
|
use std::os::unix::ffi::OsStrExt;
|
|
|
|
|
path.as_os_str().as_bytes().to_vec()
|
|
|
|
|
impl OptimisticTransactionOptionsPtr {
|
|
|
|
|
pub fn new(cmp: &RustComparator) -> Self {
|
|
|
|
|
Self(new_optimistic_transaction_options(cmp))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg(not(unix))]
|
|
|
|
|
{ path.to_string_lossy().to_string().as_bytes().to_vec() }
|
|
|
|
|
pub struct TransactionDBOptionsPtr(UniquePtr<TransactionDBOptions>);
|
|
|
|
|
|
|
|
|
|
impl Deref for TransactionDBOptionsPtr {
|
|
|
|
|
type Target = UniquePtr<TransactionDBOptions>;
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Default for BridgeStatus {
|
|
|
|
|
#[inline]
|
|
|
|
|
fn default() -> Self {
|
|
|
|
|
Self {
|
|
|
|
|
code: StatusCode::kOk,
|
|
|
|
|
subcode: StatusSubCode::kNone,
|
|
|
|
|
severity: StatusSeverity::kNoError,
|
|
|
|
|
bridge_code: StatusBridgeCode::OK,
|
|
|
|
|
}
|
|
|
|
|
impl DerefMut for TransactionDBOptionsPtr {
|
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct DB {
|
|
|
|
|
inner: UniquePtr<DBBridge>,
|
|
|
|
|
pub path: Vec<u8>,
|
|
|
|
|
pub options: Options,
|
|
|
|
|
pub default_read_options: ReadOptions,
|
|
|
|
|
pub default_write_options: WriteOptions,
|
|
|
|
|
impl TransactionDBOptionsPtr {
|
|
|
|
|
pub fn default() -> Self {
|
|
|
|
|
Self(new_tdb_options())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsafe impl Send for DB {}
|
|
|
|
|
pub struct OptimisticTransactionDBOptionsPtr(UniquePtr<OptimisticTransactionDBOptions>);
|
|
|
|
|
|
|
|
|
|
unsafe impl Sync for DB {}
|
|
|
|
|
impl Deref for OptimisticTransactionDBOptionsPtr {
|
|
|
|
|
type Target = UniquePtr<OptimisticTransactionDBOptions>;
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl DB {
|
|
|
|
|
pub fn open(options: Options, path: &Path) -> Result<DB> {
|
|
|
|
|
let path = get_path_bytes(path);
|
|
|
|
|
let_cxx_string!(cpp_path = path.clone());
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
let bridge = open_db_raw(
|
|
|
|
|
&options,
|
|
|
|
|
&cpp_path,
|
|
|
|
|
&mut status,
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(DB {
|
|
|
|
|
inner: bridge,
|
|
|
|
|
path,
|
|
|
|
|
options,
|
|
|
|
|
default_read_options: ReadOptions::default(),
|
|
|
|
|
default_write_options: WriteOptions::default(),
|
|
|
|
|
})
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
}
|
|
|
|
|
impl DerefMut for OptimisticTransactionDBOptionsPtr {
|
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn get_cf_handle(&self, name: impl AsRef<str>) -> Result<ColumnFamilyHandle> {
|
|
|
|
|
let_cxx_string!(name = name.as_ref());
|
|
|
|
|
let ret = self.inner.get_cf_handle_raw(&name);
|
|
|
|
|
if ret.is_null() {
|
|
|
|
|
Err(BridgeStatus {
|
|
|
|
|
code: StatusCode::kMaxCode,
|
|
|
|
|
subcode: StatusSubCode::kMaxSubCode,
|
|
|
|
|
severity: StatusSeverity::kSoftError,
|
|
|
|
|
bridge_code: StatusBridgeCode::NOT_FOUND_ERROR,
|
|
|
|
|
})
|
|
|
|
|
} else {
|
|
|
|
|
Ok(ret)
|
|
|
|
|
}
|
|
|
|
|
impl OptimisticTransactionDBOptionsPtr {
|
|
|
|
|
pub fn default() -> Self {
|
|
|
|
|
Self(new_odb_options())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct IteratorPtr(UniquePtr<IteratorBridge>);
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn iterator(&self, cf: &ColumnFamilyHandle, options: Option<&ReadOptions>) -> DBIterator {
|
|
|
|
|
self.inner.iterator_raw(options.unwrap_or(&self.default_read_options), cf)
|
|
|
|
|
impl Deref for IteratorPtr {
|
|
|
|
|
type Target = UniquePtr<IteratorBridge>;
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn create_column_family(&self, name: impl AsRef<str>) -> Result<()> {
|
|
|
|
|
let_cxx_string!(name = name.as_ref());
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.inner.create_column_family_raw(&self.options, &name, &mut status);
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(())
|
|
|
|
|
impl IteratorPtr {
|
|
|
|
|
pub fn to_first(&self) {
|
|
|
|
|
IteratorBridge::seek_to_first(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn to_last(&self) {
|
|
|
|
|
IteratorBridge::seek_to_last(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn next(&self) {
|
|
|
|
|
IteratorBridge::next(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn is_valid(&self) -> bool {
|
|
|
|
|
IteratorBridge::is_valid(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn seek(&self, key: impl AsRef<[u8]>) {
|
|
|
|
|
IteratorBridge::do_seek(self, key.as_ref())
|
|
|
|
|
}
|
|
|
|
|
pub fn seek_for_prev(&self, key: impl AsRef<[u8]>) {
|
|
|
|
|
IteratorBridge::do_seek_for_prev(self, key.as_ref())
|
|
|
|
|
}
|
|
|
|
|
pub fn key(&self) -> UniquePtr<Slice> {
|
|
|
|
|
IteratorBridge::key_raw(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn val(&self) -> UniquePtr<Slice> {
|
|
|
|
|
IteratorBridge::value_raw(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn status(&self) -> BridgeStatus {
|
|
|
|
|
IteratorBridge::status(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn iter(&self) -> KVIterator {
|
|
|
|
|
KVIterator { it: self }
|
|
|
|
|
}
|
|
|
|
|
pub fn keys(&self) -> KeyIterator {
|
|
|
|
|
KeyIterator { it: self }
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct KVIterator<'a> {
|
|
|
|
|
it: &'a IteratorPtr,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Iterator for KVIterator<'_> {
|
|
|
|
|
type Item = (UniquePtr<Slice>, UniquePtr<Slice>);
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
|
if self.it.is_valid() {
|
|
|
|
|
let ret = (self.it.key(), self.it.val());
|
|
|
|
|
self.next();
|
|
|
|
|
Some(ret)
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
None
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn drop_column_family(&self, name: impl AsRef<str>) -> Result<()> {
|
|
|
|
|
let_cxx_string!(name = name.as_ref());
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.inner.drop_column_family_raw(&name, &mut status);
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(())
|
|
|
|
|
|
|
|
|
|
pub struct KeyIterator<'a> {
|
|
|
|
|
it: &'a IteratorPtr,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Iterator for KeyIterator<'_> {
|
|
|
|
|
type Item = UniquePtr<Slice>;
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
|
if self.it.is_valid() {
|
|
|
|
|
let ret = self.it.key();
|
|
|
|
|
self.next();
|
|
|
|
|
Some(ret)
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
None
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct TransactionPtr(UniquePtr<TransactionBridge>);
|
|
|
|
|
|
|
|
|
|
pub fn all_cf_names(&self) -> Vec<String> {
|
|
|
|
|
self.inner.get_column_family_names_raw().iter().map(|v| v.to_string_lossy().to_string()).collect()
|
|
|
|
|
impl Deref for TransactionPtr {
|
|
|
|
|
type Target = UniquePtr<TransactionBridge>;
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn get(&self, key: impl AsRef<[u8]>, cf: &ColumnFamilyHandle, options: Option<&ReadOptions>) -> Result<Option<PinnableSlice>> {
|
|
|
|
|
|
|
|
|
|
impl TransactionPtr {
|
|
|
|
|
pub fn set_snapshot(&self) {
|
|
|
|
|
TransactionBridge::set_snapshot(self)
|
|
|
|
|
}
|
|
|
|
|
pub fn commit(&self) -> Result<()> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
let slice = self.inner.get_raw(options.unwrap_or(&self.default_read_options), cf, key.as_ref(), &mut status);
|
|
|
|
|
match status.code {
|
|
|
|
|
StatusCode::kOk => Ok(Some(PinnableSlice(slice))),
|
|
|
|
|
StatusCode::kNotFound => Ok(None),
|
|
|
|
|
_ => Err(status)
|
|
|
|
|
}
|
|
|
|
|
TransactionBridge::commit(self, &mut status);
|
|
|
|
|
status.check_err(())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn put(&self, key: impl AsRef<[u8]>, val: impl AsRef<[u8]>, cf: &ColumnFamilyHandle, options: Option<&WriteOptions>) -> Result<BridgeStatus> {
|
|
|
|
|
pub fn rollback(&self) -> Result<()> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
TransactionBridge::rollback(self, &mut status);
|
|
|
|
|
status.check_err(())
|
|
|
|
|
}
|
|
|
|
|
pub fn set_savepoint(&self) {
|
|
|
|
|
TransactionBridge::set_savepoint(self);
|
|
|
|
|
}
|
|
|
|
|
pub fn rollback_to_savepoint(&self) -> Result<()> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.inner.put_raw(options.unwrap_or(&self.default_write_options), cf,
|
|
|
|
|
key.as_ref(), val.as_ref(),
|
|
|
|
|
&mut status);
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(status)
|
|
|
|
|
TransactionBridge::rollback_to_savepoint(self, &mut status);
|
|
|
|
|
status.check_err(())
|
|
|
|
|
}
|
|
|
|
|
pub fn pop_savepoint(&self) -> Result<()> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
TransactionBridge::pop_savepoint(self, &mut status);
|
|
|
|
|
status.check_err(())
|
|
|
|
|
}
|
|
|
|
|
pub fn get(&self, transact: bool, cf: &ColumnFamilyHandle, key: impl AsRef<[u8]>) -> Result<UniquePtr<PinnableSlice>> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
if transact {
|
|
|
|
|
let ret = self.get_txn(cf, key.as_ref(), &mut status);
|
|
|
|
|
status.check_err(ret)
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
let ret = self.get_raw(cf, key.as_ref(), &mut status);
|
|
|
|
|
status.check_err(ret)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn delete(&self, key: impl AsRef<[u8]>, cf: &ColumnFamilyHandle, options: Option<&WriteOptions>) -> Result<BridgeStatus> {
|
|
|
|
|
pub fn get_for_update(&self, cf: &ColumnFamilyHandle, key: impl AsRef<[u8]>) -> Result<UniquePtr<PinnableSlice>> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.inner.delete_raw(options.unwrap_or(&self.default_write_options), cf,
|
|
|
|
|
key.as_ref(),
|
|
|
|
|
&mut status);
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(status)
|
|
|
|
|
let ret = self.get_for_update_txn(cf, key.as_ref(), &mut status);
|
|
|
|
|
status.check_err(ret)
|
|
|
|
|
}
|
|
|
|
|
pub fn del(&self, transact: bool, cf: &ColumnFamilyHandle, key: impl AsRef<[u8]>) -> Result<()> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
if transact {
|
|
|
|
|
let ret = self.del_txn(cf, key.as_ref(), &mut status);
|
|
|
|
|
status.check_err(ret)
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
let ret = self.del_raw(cf, key.as_ref(), &mut status);
|
|
|
|
|
status.check_err(ret)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn write(&self, mut updates: WriteBatch, options: Option<&WriteOptions>) -> Result<BridgeStatus> {
|
|
|
|
|
pub fn put(&self, transact: bool, cf: &ColumnFamilyHandle, key: impl AsRef<[u8]>, val: impl AsRef<[u8]>) -> Result<()> {
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.inner.write_raw(options.unwrap_or(&self.default_write_options),
|
|
|
|
|
updates.pin_mut(),
|
|
|
|
|
&mut status);
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(status)
|
|
|
|
|
if transact {
|
|
|
|
|
let ret = self.put_txn(cf, key.as_ref(), val.as_ref(), &mut status);
|
|
|
|
|
status.check_err(ret)
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
let ret = self.put_raw(cf, key.as_ref(), val.as_ref(), &mut status);
|
|
|
|
|
status.check_err(ret)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
pub fn iterator(&self, transact: bool, cf: &ColumnFamilyHandle) -> IteratorPtr {
|
|
|
|
|
if transact {
|
|
|
|
|
IteratorPtr(self.iterator_txn(cf))
|
|
|
|
|
} else {
|
|
|
|
|
IteratorPtr(self.iterator_raw(cf))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub type WriteBatch = UniquePtr<WriteBatchBridge>;
|
|
|
|
|
pub struct DBPtr(UniquePtr<TDBBridge>);
|
|
|
|
|
|
|
|
|
|
pub trait WriteBatchWrapperImp {
|
|
|
|
|
fn default() -> WriteBatch;
|
|
|
|
|
}
|
|
|
|
|
impl Deref for DBPtr {
|
|
|
|
|
type Target = UniquePtr<TDBBridge>;
|
|
|
|
|
|
|
|
|
|
impl WriteBatchWrapperImp for WriteBatch {
|
|
|
|
|
fn default() -> WriteBatch {
|
|
|
|
|
new_write_batch_raw()
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
|
&self.0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub trait WriteBatchImpl {
|
|
|
|
|
fn put(&self, key: impl AsRef<[u8]>, val: impl AsRef<[u8]>, cf: &ColumnFamilyHandle) -> Result<BridgeStatus>;
|
|
|
|
|
fn delete(&self, key: impl AsRef<[u8]>, cf: &ColumnFamilyHandle) -> Result<BridgeStatus>;
|
|
|
|
|
}
|
|
|
|
|
unsafe impl Send for DBPtr {}
|
|
|
|
|
|
|
|
|
|
impl WriteBatchImpl for WriteBatchBridge {
|
|
|
|
|
#[inline]
|
|
|
|
|
fn put(&self, key: impl AsRef<[u8]>, val: impl AsRef<[u8]>, cf: &ColumnFamilyHandle) -> Result<BridgeStatus> {
|
|
|
|
|
unsafe impl Sync for DBPtr {}
|
|
|
|
|
|
|
|
|
|
impl DBPtr {
|
|
|
|
|
pub fn open_pessimistic(options: &Options, t_options: &TransactionDBOptions, path: impl AsRef<str>) -> Result<Self> {
|
|
|
|
|
let_cxx_string!(cname = path.as_ref());
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.batch_put_raw(cf,
|
|
|
|
|
key.as_ref(), val.as_ref(),
|
|
|
|
|
&mut status);
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(status)
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
}
|
|
|
|
|
let ret = open_tdb_raw(options, t_options, &cname, &mut status);
|
|
|
|
|
status.check_err(Self(ret))
|
|
|
|
|
}
|
|
|
|
|
#[inline]
|
|
|
|
|
fn delete(&self, key: impl AsRef<[u8]>, cf: &ColumnFamilyHandle) -> Result<BridgeStatus> {
|
|
|
|
|
|
|
|
|
|
pub fn open_optimistic(options: &Options, t_options: &OptimisticTransactionDBOptions, path: impl AsRef<str>) -> Result<Self> {
|
|
|
|
|
let_cxx_string!(cname = path.as_ref());
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.batch_delete_raw(cf,
|
|
|
|
|
key.as_ref(),
|
|
|
|
|
&mut status);
|
|
|
|
|
if status.code == StatusCode::kOk {
|
|
|
|
|
Ok(status)
|
|
|
|
|
let ret = open_odb_raw(options, t_options, &cname, &mut status);
|
|
|
|
|
status.check_err(Self(ret))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn get_cf(&self, name: impl AsRef<str>) -> Option<SharedPtr<ColumnFamilyHandle>> {
|
|
|
|
|
let_cxx_string!(cname = name.as_ref());
|
|
|
|
|
let spt = self.get_cf_handle_raw(&cname);
|
|
|
|
|
if spt.is_null() {
|
|
|
|
|
None
|
|
|
|
|
} else {
|
|
|
|
|
Err(status)
|
|
|
|
|
Some(spt)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn create_cf(&self, options: &Options, name: impl AsRef<str>) -> Result<()> {
|
|
|
|
|
let_cxx_string!(name = name.as_ref());
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.create_column_family_raw(options, &name, &mut status);
|
|
|
|
|
status.check_err(())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn drop_cf(&self, name: impl AsRef<str>) -> Result<()> {
|
|
|
|
|
let_cxx_string!(name = name.as_ref());
|
|
|
|
|
let mut status = BridgeStatus::default();
|
|
|
|
|
self.drop_column_family_raw(&name, &mut status);
|
|
|
|
|
status.check_err(())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn cf_names(&self) -> Vec<String> {
|
|
|
|
|
self.get_column_family_names_raw().iter().map(|v| v.to_string_lossy().to_string()).collect()
|
|
|
|
|
}
|
|
|
|
|
}
|