Struct Map 

pub struct Map {
    name: &'static str,
    watch: Watch,
    cf: Arc<ColumnFamily>,
    engine: Arc<Engine>,
    read_options: ReadOptions,
    cache_read_options: ReadOptions,
    write_options: WriteOptions,
}

Provides typed and raw access to one RocksDB column family.

A map retains its column-family handle and the engine that owns it. Point operations reuse read and write options prepared when the map opens.

Fields

name: &'static str

watch: Watch

cf: Arc<ColumnFamily>

engine: Arc<Engine>

read_options: ReadOptions

cache_read_options: ReadOptions

write_options: WriteOptions

Implementations

impl Map

pub async fn clear(self: &Arc<Self>)

Deletes all entries that exist when the clear scan begins.

The operation scans a consistent iterator view, so later writes can remain. When debug assertions are disabled, scan errors are filtered after any preceding keys have been removed.

Panics

Panics if a scan error occurs with debug assertions enabled, RocksDB rejects a deletion, or an uncorked flush fails.

impl Map

pub fn for_clear(self: &Arc<Self>) -> impl Stream<Item = Result<Key<'_>>> + Send

Deletes each entry visible to a clear scan and yields its key.

The iterator view is fixed when the stream begins, so later writes can remain. Polling drives deletion and exposes scan errors to the caller. Each yielded key borrows cursor storage and must not be retained across another poll.

Panics

Panics if RocksDB rejects a deletion or an uncorked flush fails.

impl Map

pub fn compact_blocking(&self, opts: Options) -> Result

Compacts this map synchronously with the supplied options.

The key range and supported target placement are forwarded to RocksDB manual compaction. Unsupported level combinations and invalid target levels are returned to the caller.

impl Map

pub fn contains<K>( self: &Arc<Self>, key: &K, ) -> impl Future<Output = bool> + Send + '_ + use<'_, K>

where K: Serialize + ?Sized + Debug,

Checks whether a serialized key exists.

The key is encoded into an owned buffer before asynchronous raw-key lookup. Missing keys and database errors are folded into false.

Panics

Panics if the key cannot be serialized.

impl Map

pub fn acontains<const MAX: usize, K>( self: &Arc<Self>, key: &K, ) -> impl Future<Output = bool> + Send + '_ + use<'_, MAX, K>

where K: Serialize + ?Sized + Debug,

Checks whether a serialized key exists using fixed-capacity storage.

MAX bounds the complete encoded key without a heap fallback. Missing keys and database errors are folded into false.

Panics

Panics if the encoded key exceeds MAX or serialization otherwise fails.

impl Map

pub fn bcontains<K, B>( self: &Arc<Self>, key: &K, buf: &mut B, ) -> impl Future<Output = bool> + Send + '_ + use<'_, K, B>

where K: Serialize + ?Sized + Debug, B: Write + AsRef<[u8]>,

Checks whether a serialized key exists using a caller-supplied buffer.

Serialization appends to the supplied buffer, and lookup uses its full resulting contents. Missing keys and database errors are folded into false.

Panics

Panics if the key cannot be serialized.

impl Map

pub fn exists<'a, K>( self: &'a Arc<Self>, key: &K, ) -> impl Future<Output = Result> + Send + 'a + use<'a, K>

where K: AsRef<[u8]> + ?Sized + Debug + 'a,

Checks whether a raw key exists asynchronously.

Success returns unit, while missing keys and database failures remain errors. The lookup uses the same cache-first path as get.

impl Map

pub fn exists_blocking<K>(&self, key: &K) -> Result

where K: AsRef<[u8]> + ?Sized + Debug,

Checks synchronously whether a raw key exists.

A cache-tier existence hint can avoid a point read when absence is certain. Missing keys return the map’s not-found error, while database failures remain errors.

impl Map

pub(crate) fn maybe_exists<K>(&self, key: &K) -> bool

where K: AsRef<[u8]> + ?Sized,

Tests whether RocksDB can rule out a raw key without storage I/O.

A false result proves absence, while true still requires a point read. The configured read options restrict the probe to block cache.

impl Map

pub fn count(self: &Arc<Self>) -> impl Future<Output = usize> + Send + '_

Counts items yielded by a complete forward key scan.

Each database entry normally contributes one item. Iterator failures are counted as yielded items rather than returned to the caller.

impl Map

pub fn count_from<'a, P>( self: &'a Arc<Self>, from: &P, ) -> impl Future<Output = usize> + Send + 'a + use<'a, P>

where P: Serialize + ?Sized + Debug + 'a,

Counts forward scan items at or after a serialized lower bound.

The bound is encoded with the database serializer before seeking. Iterator failures are counted as yielded items rather than returned to the caller.

Panics

Panics if the lower bound cannot be serialized.

impl Map

pub fn raw_count_from<'a, P>( self: &'a Arc<Self>, from: &'a P, ) -> impl Future<Output = usize> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a,

Counts forward scan items at or after a raw lower bound.

The supplied bytes are used directly as the seek key. Iterator failures are counted as yielded items rather than returned to the caller.

impl Map

pub fn count_prefix<'a, P>( self: &'a Arc<Self>, prefix: &P, ) -> impl Future<Output = usize> + Send + 'a + use<'a, P>

where P: Serialize + ?Sized + Debug + 'a,

Counts forward scan items matching a serialized prefix.

The prefix is encoded with the database serializer before seeking. Iterator failures are counted as yielded items rather than returned to the caller.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn raw_count_prefix<'a, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Future<Output = usize> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a,

Counts forward scan items matching a raw prefix.

The supplied bytes are used directly for the seek and prefix test. Iterator failures are counted as yielded items rather than returned to the caller.

impl Map

pub fn del<K>(&self, key: K)

where K: Serialize + Debug,

Deletes a serialized key using an owned buffer.

The database serializer encodes the key before raw deletion. Matching watchers are notified after RocksDB accepts the removal.

Panics

Panics if serialization fails, RocksDB rejects the deletion, or an uncorked flush fails.

impl Map

pub fn adel<const MAX: usize, K>(&self, key: K)

where K: Serialize + Debug,

Deletes a serialized key using a fixed-capacity buffer.

MAX bounds the complete encoded key without a heap fallback. Matching watchers are notified after RocksDB accepts the removal.

Panics

Panics if the encoded key exceeds MAX, serialization otherwise fails, RocksDB rejects the deletion, or an uncorked flush fails.

impl Map

pub fn bdel<K, B>(&self, key: K, buf: &mut B)

where K: Serialize + Debug, B: Write + AsRef<[u8]>,

Deletes a serialized key using a caller-supplied buffer.

Serialization appends the encoded key to the supplied buffer, and deletion uses its full resulting contents. Matching watchers are notified after RocksDB accepts the removal.

Panics

Panics if serialization fails, RocksDB rejects the deletion, or an uncorked flush fails.

impl Map

pub async fn del_prefix<P>(self: &Arc<Self>, prefix: &P)

where P: Serialize + ?Sized + Debug + Sync,

Deletes every key visible under a serialized prefix.

The operation scans a consistent iterator view, so later writes can remain. When debug assertions are disabled, scan errors are filtered after any preceding keys have been removed.

Panics

Panics if the prefix cannot be serialized, a scan error occurs with debug assertions enabled, RocksDB rejects a deletion, or an uncorked flush fails.

impl Map

pub fn get<K>( self: &Arc<Self>, key: &K, ) -> impl Future<Output = Result<Handle<'_>>> + Send + use<'_, K>

where K: AsRef<[u8]> + Debug + ?Sized,

Fetches a raw key asynchronously and returns a pinned value handle.

Cache results consume cooperative scheduler budget, while misses run on the engine’s blocking pool. The returned handle keeps its RocksDB value storage pinned for the handle’s lifetime.

impl Map

pub(crate) fn get_cached<K>(&self, key: &K) -> Result<Option<Handle<'_>>>

where K: AsRef<[u8]> + Debug + ?Sized,

Fetches a raw key from block cache without storage I/O.

A cache miss returns Ok(None), while a cached absence or database failure remains an error.

impl Map

pub fn get_blocking<K>(&self, key: &K) -> Result<Handle<'_>>

where K: AsRef<[u8]> + ?Sized,

Fetches a raw key synchronously and returns a pinned value handle.

The call may block on storage and populate RocksDB caches. The returned handle keeps its value storage pinned for the handle’s lifetime.

impl Map

fn get_blocking_opts<K>( &self, key: &K, read_options: &ReadOptions, ) -> Result<Option<DBPinnableSlice<'_>>, Error>

where K: AsRef<[u8]> + ?Sized,

Performs a pinned point read with explicit RocksDB read options.

The raw RocksDB result distinguishes absence from storage failure for the caller to classify.

impl Map

pub(crate) fn get_batch<'a, S, K>( self: &'a Arc<Self>, keys: S, ) -> impl Stream<Item = Result<Handle<'_>>> + Send + 'a

where S: Stream<Item = K> + Send + 'a, K: AsRef<[u8]> + Send + Sync + 'a,

Fetches a stream of raw keys in asynchronous batches.

Each batch runs on the engine’s blocking pool and is flattened back into individual lookup results.

impl Map

pub(crate) fn _get_batch_cached<'a, I, K>( &self, keys: I, ) -> impl Iterator<Item = Result<Option<Handle<'_>>>> + Send + use<'_, I, K>

where I: Iterator<Item = &'a K> + ExactSizeIterator + Send, K: AsRef<[u8]> + Send + ?Sized + Sync + 'a,

Fetches an exact-size raw-key iterator from block cache.

Cache misses remain Ok(None), while cached values and failures retain their normal result forms.

impl Map

pub(crate) fn get_batch_blocking<'a, I, K>( &self, keys: I, ) -> impl Iterator<Item = Result<Handle<'_>>> + Send + use<'_, I, K>

where I: Iterator<Item = &'a K> + ExactSizeIterator + Send, K: AsRef<[u8]> + Send + ?Sized + Sync + 'a,

Fetches an exact-size raw-key iterator synchronously.

RocksDB performs a batched multi-get and the returned iterator classifies each point-read result.

impl Map

fn get_batch_blocking_opts<'a, I, K>( &self, keys: I, read_options: &ReadOptions, ) -> impl Iterator<Item = Result<Option<DBPinnableSlice<'_>>, Error>> + Send + use<'_, I, K>

where I: Iterator<Item = &'a K> + ExactSizeIterator + Send, K: AsRef<[u8]> + Send + ?Sized + Sync + 'a,

Performs a batched multi-get with explicit RocksDB read options.

Keys are treated as unsorted because callers do not promise column-comparator order.

impl Map

pub fn insert<K, V>(&self, key: &K, val: V)

where K: AsRef<[u8]> + ?Sized, V: AsRef<[u8]>,

Stores a raw key and raw value in this map.

The write uses the map’s configured options, flushes immediately when the engine is uncorked, and then notifies matching watchers. When the engine is corked, the surrounding cork controls flushing.

Panics

Panics if RocksDB rejects the write or an uncorked flush fails.

impl Map

pub fn keys<'a, K>( self: &'a Arc<Self>, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send

where K: Deserialize<'a> + Send,

Streams deserialized keys in ascending database order.

Each raw key is decoded with the database deserializer. Any borrowed key must not be retained across another poll.

impl Map

pub fn raw_keys(self: &Arc<Self>) -> impl Stream<Item = Result<Key<'_>>> + Send

Streams raw keys in ascending database order.

The scan begins at the first key in the column family. Yielded keys borrow cursor storage and must not be retained across another poll.

impl Map

pub fn keys_from<'a, K, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + use<'a, K, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send,

Streams deserialized keys forward from a serialized lower bound.

The scan begins at the first key not less than the encoded bound. Any borrowed key must not be retained across another poll.

Panics

Panics if the lower bound cannot be serialized.

impl Map

pub fn keys_from_raw<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw keys forward from a serialized lower bound.

The scan begins at the first key not less than the encoded bound. Yielded keys borrow cursor storage and must not be retained across another poll.

Panics

Panics if the lower bound cannot be serialized.

impl Map

pub fn keys_raw_from<'a, K, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + use<'a, K, P>

where P: AsRef<[u8]> + ?Sized + Debug + Sync, K: Deserialize<'a> + Send,

Streams deserialized keys forward from a raw lower bound.

The supplied bytes are used directly as the seek position. Any borrowed key must not be retained across another poll.

impl Map

pub fn raw_keys_from<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + use<'_, P>

where P: AsRef<[u8]> + ?Sized + Debug,

Streams raw keys forward from a raw lower bound.

The supplied bytes are used directly as the seek position. Yielded keys borrow cursor storage and must not be retained across another poll.

impl Map

pub fn keys_prefix<'a, K, P>( self: &'a Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + use<'a, K, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send,

Streams deserialized keys matching a serialized prefix in ascending order.

The scan begins at the encoded prefix and stops at the first nonmatching key. Any borrowed key must not be retained across another poll.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn keys_prefix_raw<P>( self: &Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw keys matching a serialized prefix in ascending order.

The scan begins at the encoded prefix and stops at the first nonmatching key. Yielded keys borrow cursor storage and must not be retained across another poll.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn keys_raw_prefix<'a, K, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a, K: Deserialize<'a> + Send + 'a,

Streams deserialized keys matching a raw prefix in ascending order.

The supplied bytes are used directly for the seek and prefix test. Any borrowed key must not be retained across another poll.

impl Map

pub fn raw_keys_prefix<'a, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a,

Streams raw keys matching a raw prefix in ascending order.

The supplied bytes are used directly for the seek and prefix test. Yielded keys borrow cursor storage and must not be retained across another poll.

impl Map

pub fn put<K, V>(&self, key: K, val: V)

where K: Serialize + Debug, V: Serialize,

Stores a serialized key and serialized value using owned buffers.

Both values pass through the database serializer before raw insertion. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if either value cannot be serialized, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn put_raw<K, V>(&self, key: K, val: V)

where K: Serialize + Debug, V: AsRef<[u8]>,

Stores a serialized key and raw value using an owned key buffer.

The key passes through the database serializer before raw insertion. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if the key cannot be serialized, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn raw_put<K, V>(&self, key: K, val: V)

where K: AsRef<[u8]>, V: Serialize,

Stores a raw key and serialized value using an owned value buffer.

The value passes through the database serializer before raw insertion. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if the value cannot be serialized, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn put_aput<const VMAX: usize, K, V>(&self, key: K, val: V)

where K: Serialize + Debug, V: Serialize,

Stores a serialized key and value with fixed-capacity value storage.

The key uses an owned buffer, while VMAX bounds the complete encoded value without a heap fallback. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if serialization fails, the encoded value exceeds VMAX, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn aput_put<const KMAX: usize, K, V>(&self, key: K, val: V)

where K: Serialize + Debug, V: Serialize,

Stores a serialized key and value with fixed-capacity key storage.

KMAX bounds the complete encoded key without a heap fallback, while the value uses an owned buffer. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if serialization fails, the encoded key exceeds KMAX, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn aput<const KMAX: usize, const VMAX: usize, K, V>(&self, key: K, val: V)

where K: Serialize + Debug, V: Serialize,

Stores a serialized key and value using fixed-capacity buffers.

KMAX and VMAX bound the complete encoded key and value without heap fallbacks. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if serialization fails, either encoded value exceeds its capacity, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn aput_raw<const KMAX: usize, K, V>(&self, key: K, val: V)

where K: Serialize + Debug, V: AsRef<[u8]>,

Stores a serialized key and raw value with fixed-capacity key storage.

KMAX bounds the complete encoded key without a heap fallback. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if serialization fails, the encoded key exceeds KMAX, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn raw_aput<const VMAX: usize, K, V>(&self, key: K, val: V)

where K: AsRef<[u8]>, V: Serialize,

Stores a raw key and serialized value with fixed-capacity value storage.

VMAX bounds the complete encoded value without a heap fallback. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if serialization fails, the encoded value exceeds VMAX, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn bput<K, V, Bk, Bv>(&self, key: K, val: V, buf: (Bk, Bv))

where K: Serialize + Debug, V: Serialize, Bk: Write + AsRef<[u8]>, Bv: Write + AsRef<[u8]>,

Stores a serialized key and value using caller-supplied buffers.

Serialization appends the encoded key and value to the tuple’s first and second buffers, respectively. The write uses each buffer’s full resulting contents and then notifies matching watchers after RocksDB accepts it.

Panics

Panics if either value cannot be serialized, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn bput_raw<K, V, Bk>(&self, key: K, val: V, buf: Bk)

where K: Serialize + Debug, V: AsRef<[u8]>, Bk: Write + AsRef<[u8]>,

Stores a serialized key and raw value using a caller-supplied key buffer.

Serialization appends the encoded key to the supplied buffer, and the write uses its full resulting contents. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if the key cannot be serialized, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn raw_bput<K, V, Bv>(&self, key: K, val: V, buf: Bv)

where K: AsRef<[u8]>, V: Serialize, Bv: Write + AsRef<[u8]>,

Stores a raw key and serialized value using a caller-supplied value buffer.

Serialization appends the encoded value to the supplied buffer, and the write uses its full resulting contents. Matching watchers are notified after RocksDB accepts the write.

Panics

Panics if the value cannot be serialized, RocksDB rejects the write, or an uncorked flush fails.

impl Map

pub fn qry<K>( self: &Arc<Self>, key: &K, ) -> impl Future<Output = Result<Handle<'_>>> + Send + use<'_, K>

where K: Serialize + ?Sized + Debug,

Fetches a serialized key asynchronously using an owned buffer.

The key is encoded with the database serializer before raw lookup. The returned handle keeps its RocksDB value storage pinned for the handle’s lifetime.

Panics

Panics if the key cannot be serialized.

impl Map

pub fn aqry<const MAX: usize, K>( self: &Arc<Self>, key: &K, ) -> impl Future<Output = Result<Handle<'_>>> + Send + use<'_, MAX, K>

where K: Serialize + ?Sized + Debug,

Fetches a serialized key asynchronously using fixed-capacity storage.

MAX bounds the complete encoded key without a heap fallback. The returned handle keeps its RocksDB value storage pinned for the handle’s lifetime.

Panics

Panics if the encoded key exceeds MAX or serialization otherwise fails.

impl Map

pub fn bqry<K, B>( self: &Arc<Self>, key: &K, buf: &mut B, ) -> impl Future<Output = Result<Handle<'_>>> + Send + use<'_, K, B>

where K: Serialize + ?Sized + Debug, B: Write + AsRef<[u8]>,

Fetches a serialized key asynchronously using a caller-supplied buffer.

Serialization appends to the supplied buffer, and lookup uses its full resulting contents. The returned handle keeps its RocksDB value storage pinned for the handle’s lifetime.

Panics

Panics if the key cannot be serialized.

impl Map

pub(crate) fn qry_batch<'a, S, K>( self: &'a Arc<Self>, keys: S, ) -> impl Stream<Item = Result<Handle<'_>>> + Send + 'a

where S: Stream<Item = K> + Send + 'a, K: Serialize + Debug + 'a,

Fetches a stream of structured keys in serialized asynchronous batches.

Each batch is encoded, run on the engine’s blocking pool, and flattened back into individual lookup results.

Panics

Panics if an input key cannot be serialized.

impl Map

pub fn remove<K>(&self, key: &K)

where K: AsRef<[u8]> + ?Sized + Debug,

Deletes a raw key from this map.

The removal uses the map’s configured options, flushes immediately when the engine is uncorked, and then notifies matching watchers. When the engine is corked, the surrounding cork controls flushing.

Panics

Panics if RocksDB rejects the deletion or an uncorked flush fails.

impl Map

pub fn rev_keys<'a, K>( self: &'a Arc<Self>, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send

where K: Deserialize<'a> + Send,

Streams deserialized keys in descending database order.

Each raw key is decoded with the database deserializer. Any borrowed key must not be retained across another poll.

impl Map

pub fn rev_raw_keys( self: &Arc<Self>, ) -> impl Stream<Item = Result<Key<'_>>> + Send

Streams raw keys in descending database order.

The scan begins at the last key in the column family. Yielded keys borrow cursor storage and must not be retained across another poll.

impl Map

pub fn rev_keys_from<'a, K, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + use<'a, K, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send,

Streams deserialized keys backward from a serialized upper bound.

The scan begins at the greatest key not greater than the encoded bound. Any borrowed key must not be retained across another poll.

Panics

Panics if the upper bound cannot be serialized.

impl Map

pub fn rev_keys_from_raw<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw keys backward from a serialized upper bound.

The scan begins at the greatest key not greater than the encoded bound. Yielded keys borrow cursor storage and must not be retained across another poll.

Panics

Panics if the upper bound cannot be serialized.

impl Map

pub fn rev_keys_raw_from<'a, K, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + use<'a, K, P>

where P: AsRef<[u8]> + ?Sized + Debug + Sync, K: Deserialize<'a> + Send,

Streams deserialized keys backward from a raw upper bound.

The supplied bytes are used directly as the reverse seek position. Any borrowed key must not be retained across another poll.

impl Map

pub fn rev_raw_keys_from<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + use<'_, P>

where P: AsRef<[u8]> + ?Sized + Debug,

Streams raw keys backward from a raw upper bound.

The supplied bytes are used directly as the reverse seek position. Yielded keys borrow cursor storage and must not be retained across another poll.

impl Map

pub fn rev_keys_prefix<'a, K, P>( self: &'a Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + use<'a, K, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send,

Streams deserialized keys from a reverse seek at a serialized prefix.

The encoded prefix is both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Any borrowed key must not be retained across another poll.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn rev_keys_prefix_raw<P>( self: &Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw keys from a reverse seek at a serialized prefix.

The encoded prefix is both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Yielded keys borrow cursor storage and must not be retained across another poll.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn rev_keys_raw_prefix<'a, K, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<Key<'_, K>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a, K: Deserialize<'a> + Send + 'a,

Streams deserialized keys from a reverse seek at a raw prefix.

The supplied bytes are both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Any borrowed key must not be retained across another poll.

impl Map

pub fn rev_raw_keys_prefix<'a, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<Key<'_>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a,

Streams raw keys from a reverse seek at a raw prefix.

The supplied bytes are both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Yielded keys borrow cursor storage and must not be retained across another poll.

impl Map

pub fn rev_stream<'a, K, V>( self: &'a Arc<Self>, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send

where K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized key-value entries in descending database order.

Each raw pair is decoded with the database deserializer. Any borrowed key or value must not be retained across another poll of the stream.

impl Map

pub fn rev_raw_stream( self: &Arc<Self>, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send

Streams raw key-value entries in descending database order.

The scan begins at the last key in the column family. Yielded keys and values borrow cursor storage and must not be retained across another poll.

impl Map

pub fn rev_stream_from<'a, K, V, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + use<'a, K, V, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized entries backward from a serialized upper bound.

The scan begins at the greatest key not greater than the encoded bound. Any borrowed key or value must not be retained across another poll of the stream.

Panics

Panics if the upper bound cannot be serialized.

impl Map

pub fn rev_stream_from_raw<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw entries backward from a serialized upper bound.

The scan begins at the greatest key not greater than the encoded bound. Yielded keys and values borrow cursor storage and must not be retained across another poll.

Panics

Panics if the upper bound cannot be serialized.

impl Map

pub fn rev_stream_raw_from<'a, K, V, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + use<'a, K, V, P>

where P: AsRef<[u8]> + ?Sized + Debug + Sync, K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized entries backward from a raw upper bound.

The supplied bytes are used directly as the reverse seek position. Any borrowed key or value must not be retained across another poll of the stream.

impl Map

pub fn rev_raw_stream_from<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + use<'_, P>

where P: AsRef<[u8]> + ?Sized + Debug,

Streams raw entries backward from a raw upper bound.

The supplied bytes are used directly as the reverse seek position. Yielded keys and values borrow cursor storage and must not be retained across another poll.

impl Map

pub fn rev_stream_prefix<'a, K, V, P>( self: &'a Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + use<'a, K, V, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized entries from a reverse seek at a serialized prefix.

The encoded prefix is both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Any borrowed key or value must not be retained across another poll.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn rev_stream_prefix_raw<P>( self: &Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw entries from a reverse seek at a serialized prefix.

The encoded prefix is both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Yielded keys and values borrow cursor storage and must not be retained across another poll.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn rev_stream_raw_prefix<'a, K, V, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a, K: Deserialize<'a> + Send + 'a, V: Deserialize<'a> + Send + 'a,

Streams deserialized entries from a reverse seek at a raw prefix.

The supplied bytes are both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Any borrowed key or value must not be retained across another poll.

impl Map

pub fn rev_raw_stream_prefix<'a, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a,

Streams raw entries from a reverse seek at a raw prefix.

The supplied bytes are both the seek position and the predicate. Under bytewise ordering, longer keys with the prefix sort above this starting point, so the scan normally reaches only an exact-key match. Yielded keys and values borrow cursor storage and must not be retained across another poll.

impl Map

pub fn stream<'a, K, V>( self: &'a Arc<Self>, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send

where K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized key-value entries in ascending database order.

Each raw pair is decoded with the database deserializer. Any borrowed key or value must not be retained across another poll of the stream.

impl Map

pub fn raw_stream( self: &Arc<Self>, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send

Streams raw key-value entries in ascending database order.

The scan begins at the first key in the column family. Yielded keys and values borrow cursor storage and must not be retained across another poll.

impl Map

pub fn stream_from<'a, K, V, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + use<'a, K, V, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized entries forward from a serialized lower bound.

The scan begins at the first key not less than the encoded bound. Any borrowed key or value must not be retained across another poll of the stream.

Panics

Panics if the lower bound cannot be serialized.

impl Map

pub fn stream_from_raw<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw entries forward from a serialized lower bound.

The scan begins at the first key not less than the encoded bound. Yielded keys and values borrow cursor storage and must not be retained across another poll.

Panics

Panics if the lower bound cannot be serialized.

impl Map

pub fn stream_raw_from<'a, K, V, P>( self: &'a Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + use<'a, K, V, P>

where P: AsRef<[u8]> + ?Sized + Debug + Sync, K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized entries forward from a raw lower bound.

The supplied bytes are used directly as the seek position. Any borrowed key or value must not be retained across another poll of the stream.

impl Map

pub fn raw_stream_from<P>( self: &Arc<Self>, from: &P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + use<'_, P>

where P: AsRef<[u8]> + ?Sized + Debug,

Streams raw entries forward from a raw lower bound.

The supplied bytes are used directly as the seek position. Yielded keys and values borrow cursor storage and must not be retained across another poll.

impl Map

pub fn stream_prefix<'a, K, V, P>( self: &'a Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + use<'a, K, V, P>

where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send, V: Deserialize<'a> + Send,

Streams deserialized entries matching a serialized prefix in ascending order.

The scan begins at the encoded prefix and stops at the first nonmatching key. Any borrowed key or value must not be retained across another poll of the stream.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn stream_prefix_raw<P>( self: &Arc<Self>, prefix: &P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + use<'_, P>

where P: Serialize + ?Sized + Debug,

Streams raw entries matching a serialized prefix in ascending order.

The scan begins at the encoded prefix and stops at the first nonmatching key. Yielded keys and values borrow cursor storage and must not be retained across another poll.

Panics

Panics if the prefix cannot be serialized.

impl Map

pub fn stream_raw_prefix<'a, K, V, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<KeyVal<'_, K, V>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a, K: Deserialize<'a> + Send + 'a, V: Deserialize<'a> + Send + 'a,

Streams deserialized entries matching a raw prefix in ascending order.

The supplied bytes are used directly for the seek and prefix test. Any borrowed key or value must not be retained across another poll of the stream.

impl Map

pub fn raw_stream_prefix<'a, P>( self: &'a Arc<Self>, prefix: &'a P, ) -> impl Stream<Item = Result<KeyVal<'_>>> + Send + 'a

where P: AsRef<[u8]> + ?Sized + Debug + Sync + 'a,

Streams raw entries matching a raw prefix in ascending order.

The supplied bytes are used directly for the seek and prefix test. Yielded keys and values borrow cursor storage and must not be retained across another poll.

impl Map

pub fn watch_prefix<K>(&self, prefix: K) -> impl Future<Output = ()> + Send + '_

where K: Serialize,

Waits for the next map mutation under a serialized prefix.

The prefix is encoded once before subscription. The stored subscription is reaped after a later matching notification observes that its receiver has closed.

Panics

Panics if prefix serialization fails, the watcher mutex is poisoned, or the sender disappears before notification.

impl Map

pub fn watch_raw_prefix_once<K>( &self, prefix: K, ) -> impl Future<Output = ()> + Send + '_

where K: AsRef<[u8]>,

Waits once for a map mutation under a raw prefix.

The prefix is copied into the subscription table. A drop guard removes the entry immediately when this future owns its last receiver.

Panics

Panics if the watcher mutex is poisoned or the sender disappears before notification.

impl Map

pub fn watch_raw_prefix<'a, K>( &self, prefix: &'a K, ) -> impl Future<Output = ()> + Send + use<K>

where K: AsRef<[u8]> + ?Sized + 'a,

Waits for the next map mutation under a borrowed raw prefix.

The prefix is copied into the subscription table. The stored subscription is reaped after a later matching notification observes that its receiver has closed.

Panics

Panics if the watcher mutex is poisoned or the sender disappears before notification.

impl Map

fn subscribe(&self, key: KeyBuf) -> Receiver<()>

Subscribes to mutations under an owned raw prefix.

Existing prefixes share one watch sender, while new prefixes create a fresh channel.

Panics

Panics if the watcher mutex is poisoned.

impl Map

pub(crate) fn notify<K>(&self, key: &K)

where K: AsRef<[u8]> + Ord + ?Sized,

Notifies subscriptions whose prefixes match a mutated raw key.

Closed subscriptions discovered during the ordered prefix walk are removed in the same critical section. Live subscriptions remain available for later mutations.

Panics

Panics if the watcher mutex is poisoned.

impl Map

pub(crate) fn open( engine: &Arc<Engine>, name: &'static str, ) -> Result<Arc<Self>>

Opens a map for a named column family.

The returned map keeps the engine alive for at least as long as its column-family handle. Its read and write options are initialized from the engine configuration.

pub fn sort(&self) -> Result

Flush this map’s memtable to SST files (a RocksDB LSM-tree flush).

Forces the column family’s buffered writes out of memory into the on-disk LSM tree. An LSM flush, not a libc fflush(3) or fsync(2), and distinct from the engine’s flush and sync, which act on the write-ahead log.

pub fn property_integer(&self, name: &CStr) -> Result<u64>

Reads an integer RocksDB property for this map.

The property query is scoped to this map’s column family. Engine errors are returned to the caller.

pub fn property(&self, name: &str) -> Result<String>

Reads a string RocksDB property for this map.

The property query is scoped to this map’s column family. Engine errors are returned to the caller.

pub fn name(&self) -> &str

Returns the column-family name of this map.

The name is fixed when the map opens and lives for the duration of the process.

pub(crate) fn engine(&self) -> &Arc<Engine>

Returns the engine that owns this map.

The borrowed Arc keeps the same identity used to open the column-family handle.

pub(crate) fn cf(&self) -> impl AsColumnFamilyRef + '_

Returns this map’s RocksDB column-family handle.

The handle remains valid because the map retains its owning engine.

pub(crate) fn cf_id(&self) -> u32

Returns the numeric RocksDB identifier for this column family.

The identifier belongs to this map’s engine and must not be compared across engines.

Trait Implementations

impl Debug for Map

fn fmt(&self, out: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Map

fn fmt(&self, out: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.