Today, I’m happy to announce that I’ve released keyv, a Rust library designed to simplify key-value storage and increase its flexibility.
What is keyv?
keyv is a simple key-value storage library that supports multiple backends. It offers a consistent interface for key-value storage across these backends. With support for TTL-based expiry, it’s versatile enough to act as either a cache or a persistent key-value store, adapting to your needs.
Where Could You Use keyv?
Imagine you’re working on a high-traffic web service that needs to cache user sessions. keyv can swiftly partner with a Redis backend to give you that in-memory speed. Or, let’s say you’re building an application that requires durable storage. Here, keyv with PostgreSQL would be your go-to.
Here are some scenarios where keyv shines:
Caching frequently accessed data with in-memory databases like Redis.
Persisting user settings or session data in SQL databases such as SQLite or PostgreSQL.
Building a quick prototype where you need a straightforward storage solution without the overhead of complex configurations.
Getting Started with keyv
Setting up keyv is a breeze. You can start by adding it to your Cargo.toml:
keyv = “0.2.1”
or by running:
Store Adapters
keyv embraces versatility with multiple store adapters, allowing seamless integration with various storage backends. Activate them with a feature flag:
full: All-in-one feature for enabling every available adapter.
Redis: In-memory storage for speedy cache.
Postgres: Robust and structured data storage.
MySQL: Reliable storage within the MySQL ecosystem.
MongoDB: Schema flexibility with a NoSQL approach.
SQLite: Simple setup, ideal for development.
Add keyv with your chosen adapter:
Example Uses of keyv
keyv provides a straightforward way to manage key-value data. Here’s how you can use it in your Rust projects.
InMemory (default)
#[tokio::main]
async fn main() {
// Initialize `keyv` with default in-memory storage
let keyv = Keyv::default();
// Setting a value
keyv.set(“my_key”, “my_value”).await.unwrap();
// Getting a value
if let Some(value) = keyv.get::<String>(“my_key”).await.unwrap() {
println!(“Retrieved value: {}”, value);
} else {
println!(“Value not found”);
}
// Removing a value
keyv.remove(“my_key”).await.unwrap();
}
Using with Store adapters
Adjust keyv to use different store adapters like Redis.
use keyv::{adapter::redis::RedisStoreBuilder, Keyv};
#[cfg(feature = “redis”)]
#[tokio::main]
async fn main() {
// Initialize Redis storage with default TTL
let store = RedisStoreBuilder::new()
.uri(“redis://localhost:6379”)
.default_ttl(3600) // 1 hour TTL
.build()
.await
.unwrap();
// Create `keyv` instance with Redis store
let keyv = Keyv::try_new(store).await.unwrap();
// Set and retrieve a value
keyv.set(“my_key”, “my_value”).await.unwrap();
let value: String = keyv
.get(“my_key”)
.await
.unwrap()
.expect(“Key not found”);
println!(“Retrieved value: {}”, value);
}
#[cfg(not(feature = “redis”))]
fn main() {
println!(“This example requires the ‘redis’ feature. Please enable it.”);
}
Easy to set up and super straightforward to use, give it a whirl in your next project. If you run into any issues or have suggestions, feel free to reach out on GitHub.
Happy coding! I hope keyv makes your key-value data storage a bit easier!
