5 unstable releases

0.2.1 Apr 18, 2024
0.2.0 Apr 18, 2024
0.1.0 Apr 16, 2024
0.0.2-alpha.1 Dec 27, 2023
0.0.1 Dec 27, 2023

#714 in Database interfaces

MIT license

62KB
928 lines

Simple key-value storage with support for multiple backends Keyv provides a consistent interface for key-value storage across multiple backends via storage adapters. It supports TTL based expiry, making it suitable as a cache or a persistent key-value store.

Usage

Instalation

cargo add keyv

Store Adapters

Keyv supports multiple store adapters, you can enable them by specifying the feature flag.

  • full: Enables all available adapters.
  • redis: Redis store adapter.
  • postgres: PostgreSQL store adapter.
  • mysql: MySQL store adapter.
  • mongodb: MongoDB store adapter.
  • sqlite: SQLite store adapter.
cargo add keyv --features <store>

Initialization

By default, everything is stored in memory, you can optionally also install a storage adapter.

  • Inmemory default

    let keyv = Keyv::default();
    
  • Postgres

       use keyv::{adapter::postgres::PostgresStoreBuilder, Keyv};
    
       let store = PostgresStoreBuilder::new()
           .uri("postgresql://postgres:postgres@localhost:5432")
           .table_name("custom_table_name")
           .build()
           .await.unwrap();
    
       let keyv = Keyv::try_new(store).await.unwrap();
    
  • Redis

      use keyv::{adapter::redis::RedisStoreBuilder, Keyv};
    
      let store = RedisStoreBuilder::new()
          .uri("redis://localhost:6379")
          .default_ttl(3600)
          .build()
          .await
          .unwrap();
    
       let keyv = Keyv::try_new(store).await.unwrap();
    

Interacting with Store


use keyv::Keyv;

#[tokio::main]
async fn main() {
    let keyv = Keyv::default();
    keyv.set("number", 42).await.unwrap();
    keyv.set("number", 10).await.unwrap();
    keyv.set("array", vec!["hola", "test"]).await.unwrap();
    keyv.set("string", "life long").await.unwrap();

    match keyv.get("number").await.unwrap() {
        Some(number) => {
            let number: i32 = serde_json::from_value(number).unwrap();
            assert_eq!(number, 10);
        }
        None => assert!(false),
    }

    match keyv.get("string").await.unwrap() {
        Some(string) => {
            let string: String = serde_json::from_value(string).unwrap();
            assert_eq!(string, "life long");
        }
        None => assert!(false),
    }

    match keyv.get("array").await.unwrap() {
        Some(array) => {
            let array: Vec<String> = serde_json::from_value(array).unwrap();
            assert_eq!(array, vec!["hola".to_string(), "test".to_string()])
        }
        None => assert!(false),
    }

    match keyv.remove_many(&["number", "string"]).await {
        Ok(_) => {}
        Err(_) => assert!(false),
    }
}

Dependencies

~3–23MB
~349K SLoC