pub struct Keyspace(/* private fields */);
Expand description
A keyspace is a single logical database which can house multiple partitions
In your application, you should create a single keyspace and keep it around for as long as needed (as long as you are using its partitions).
Implementations§
source§impl Keyspace
impl Keyspace
sourcepub fn batch(&self) -> Batch
pub fn batch(&self) -> Batch
Initializes a new atomic write batch.
Items may be written to multiple partitions, which will be be updated atomically when the batch is committed.
§Examples
let mut batch = keyspace.batch();
assert_eq!(partition.len()?, 0);
batch.insert(&partition, "1", "abc");
batch.insert(&partition, "3", "abc");
batch.insert(&partition, "5", "abc");
assert_eq!(partition.len()?, 0);
batch.commit()?;
assert_eq!(partition.len()?, 3);
sourcepub fn write_buffer_size(&self) -> u64
pub fn write_buffer_size(&self) -> u64
Returns the current write buffer size (active + sealed memtables).
sourcepub fn journal_count(&self) -> usize
pub fn journal_count(&self) -> usize
sourcepub fn disk_space(&self) -> u64
pub fn disk_space(&self) -> u64
sourcepub fn persist(&self, mode: PersistMode) -> Result<()>
pub fn persist(&self, mode: PersistMode) -> Result<()>
Flushes the active journal to OS buffers. The durability depends on the PersistMode
used.
Persisting only affects durability, NOT consistency! Even without flushing data is crash-safe.
§Examples
let keyspace = Config::new(folder).open()?;
let items = keyspace.open_partition("my_items", PartitionCreateOptions::default())?;
items.insert("a", "hello")?;
keyspace.persist(PersistMode::SyncAll)?;
§Errors
Returns error, if an IO error occured.
sourcepub fn delete_partition(&self, handle: PartitionHandle) -> Result<()>
pub fn delete_partition(&self, handle: PartitionHandle) -> Result<()>
Destroys the partition, removing all data associated with it.
§Errors
Will return Err
if an IO error occurs.
sourcepub fn open_partition(
&self,
name: &str,
create_options: PartitionCreateOptions
) -> Result<PartitionHandle>
pub fn open_partition( &self, name: &str, create_options: PartitionCreateOptions ) -> Result<PartitionHandle>
sourcepub fn partition_count(&self) -> usize
pub fn partition_count(&self) -> usize
Returns the amount of partitions
sourcepub fn list_partitions(&self) -> Vec<Arc<str>>
pub fn list_partitions(&self) -> Vec<Arc<str>>
Gets a list of all partition names in the keyspace
sourcepub fn partition_exists(&self, name: &str) -> bool
pub fn partition_exists(&self, name: &str) -> bool
Returns true
if the partition with the given name exists.
§Examples
assert!(!keyspace.partition_exists("default"));
keyspace.open_partition("default", PartitionCreateOptions::default())?;
assert!(keyspace.partition_exists("default"));
sourcepub fn instant(&self) -> Instant
pub fn instant(&self) -> Instant
Gets the current sequence number.
Can be used to start a cross-partition snapshot, using PartitionHandle::snapshot_at
.
§Examples
let partition1 = keyspace.open_partition("default", PartitionCreateOptions::default())?;
let partition2 = keyspace.open_partition("another", PartitionCreateOptions::default())?;
partition1.insert("abc1", "abc")?;
partition2.insert("abc2", "abc")?;
let instant = keyspace.instant();
let snapshot1 = partition1.snapshot_at(instant);
let snapshot2 = partition2.snapshot_at(instant);
assert!(partition1.contains_key("abc1")?);
assert!(partition2.contains_key("abc2")?);
assert!(snapshot1.contains_key("abc1")?);
assert!(snapshot2.contains_key("abc2")?);
partition1.insert("def1", "def")?;
partition2.insert("def2", "def")?;
assert!(!snapshot1.contains_key("def1")?);
assert!(!snapshot2.contains_key("def2")?);
assert!(partition1.contains_key("def1")?);
assert!(partition2.contains_key("def2")?);