Struct Database

pub struct Database<PA> { /* private fields */ }

A Database provides methods to access data.

The config private field is wrapped in an Arc to be shared among threads.

Implementations

impl<PA> Database<PA>

where PA: AsRef<Path> + Send + Sync + Clone + 'static,

pub fn new(path: PA, extension: Option<&str>) -> Self

Create a new Database with a mandatory path and an optional file extension.

Examples

use csv_db::Database;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, PartialEq, Serialize)]
struct User {
    id: usize,
    first_name: String,
    last_name: String,
    age: u32,
}

#[tokio::main]
async fn main() {
    let db = Database::new("data", None);
}

pub async fn find<T, P>( &self, collection: &str, predicate: P, ) -> Result<Vec<T>, Box<dyn Error>>

where T: Serialize + for<'de> Deserialize<'de> + Send + 'static, P: FnMut(&T) -> bool,

Find documents by filtering with a predicate on a collection.

Examples

use csv_db::Database;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, PartialEq, Serialize)]
struct User {
    id: usize,
    first_name: String,
    last_name: String,
    age: u32,
}

#[tokio::main]
async fn main() {
    let db = Database::new("data", None);

    let user = User {
        id: 1,
        first_name: String::from("First"),
        last_name: String::from("Last"),
        age: 20,
    };

    let adults = db
        .find("users", |u: &User| u.age >= 18)
        .await
        .expect("Problem searching user.");
}

pub async fn insert<T>( &self, collection: &str, document: T, ) -> Result<(), Box<dyn Error>>

where T: Serialize + for<'de> Deserialize<'de> + Send + 'static,

Insert a new document into a collection.

Examples

use csv_db::Database;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, PartialEq, Serialize)]
struct User {
    id: usize,
    first_name: String,
    last_name: String,
    age: u32,
}

#[tokio::main]
async fn main() {
    let db = Database::new("data", None);

    let user = User {
        id: 1,
        first_name: String::from("First"),
        last_name: String::from("Last"),
        age: 20,
    };

    db.insert("users", user)
        .await
        .expect("Problem inserting user.");
}

pub async fn delete<T, P>( &self, collection: &str, predicate: P, ) -> Result<(), Box<dyn Error>>

where T: Serialize + for<'de> Deserialize<'de> + PartialEq + Send + 'static, P: FnMut(&&T) -> bool,

Delete a document by filtering with a predicate from a collection.

Examples

use csv_db::Database;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, PartialEq, Serialize)]
struct User {
    id: usize,
    first_name: String,
    last_name: String,
    age: u32,
}

#[tokio::main]
async fn main() {
    let db = Database::new("data", None);

    db.delete("users", |u: &&User| u.id == 1)
        .await
        .expect("Problem deleting user.");
}

pub async fn update<T, P>( &self, collection: &str, document: T, predicate: P, ) -> Result<(), Box<dyn Error>>

where T: Serialize + for<'de> Deserialize<'de> + PartialEq + Send + 'static, P: FnMut(&&T) -> bool,

Update a document by filtering with a predicate on a collection.

Examples

use csv_db::Database;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, PartialEq, Serialize)]
struct User {
    id: usize,
    first_name: String,
    last_name: String,
    age: u32,
}

#[tokio::main]
async fn main() {
    let db = Database::new("data", None);

    let user = User {
        id: 1,
        first_name: String::from("First"),
        last_name: String::from("Last"),
        age: 21,
    };

    db.update("users", user, |u: &&User| u.id == 1)
        .await
        .expect("Problem updating user.");
}