1 
use std::time::SystemTime;
2 

            

        

            

                3
            

            

                
            

            

                
use bonsaidb::core::connection::{Connection, StorageConnection};

            

        

            

                4
            

            

                
            

            

                
use bonsaidb::core::schema::{Collection, SerializedCollection};

            

        

            

                5
            

            

                
            

            

                
use bonsaidb::local::config::{Builder, StorageConfiguration};

            

        

            

                6
            

            

                
            

            

                
use bonsaidb::local::Storage;

            

        

            

                7
            

            

                
            

            

                
use serde::{Deserialize, Serialize};

            

        

            

                8
            

            

                
            

            

                

            

        

            

                9
            

            

                16
            

            

                
#[derive(Debug, Clone, Serialize, Deserialize, Collection)]

            

        

            

                10
            

            

                
            

            

                
#[collection(name = "messages")]

            

        

            

                11
            

            

                
            

            

                
struct Message {

            

        

            

                12
            

            

                
            

            

                
    pub timestamp: SystemTime,

            

        

            

                13
            

            

                
            

            

                
    pub contents: String,

            

        

            

                14
            

            

                
            

            

                
}

            

        

            

                15
            

            

                
            

            

                

            

        

            

                16
            

            

                1
            

            

                
fn main() -> Result<(), bonsaidb::core::Error> {

            

        

            

                17
            

            

                1
            

            

                
    let storage =

            

        

            

                18
            

            

                1
            

            

                
        Storage::open(StorageConfiguration::new("basic.bonsaidb").with_schema::<Message>()?)?;

            

        

            

                19
            

            

                1
            

            

                
    let messages = storage.create_database::<Message>("messages", true)?;

            

        

            

                20
            

            

                
            

            

                

            

        

            

                21
            

            

                1
            

            

                
    let private_messages = storage.create_database::<Message>("private-messages", true)?;

            

        

            

                22
            

            

                
            

            

                

            

        

            

                23
            

            

                1
            

            

                
    insert_a_message(&messages, "Hello, World!")?;

            

        

            

                24
            

            

                1
            

            

                
    insert_a_message(&private_messages, "Hey!")?;

            

        

            

                25
            

            

                
            

            

                

            

        

            

                26
            

            

                1
            

            

                
    Ok(())

            

        

            

                27
            

            

                1
            

            

                
}

            

        

            

                28
            

            

                
            

            

                

            

        

            

                29
            

            

                
            

            

                
// ANCHOR: reusable-code

            

        

            

                30
            

            

                
            

            

                
fn insert_a_message<C: Connection>(

            

        

            

                31
            

            

                
            

            

                
    connection: &C,

            

        

            

                32
            

            

                
            

            

                
    value: &str,

            

        

            

                33
            

            

                
            

            

                
) -> Result<(), bonsaidb::core::Error> {

            

        

            

                34
            

            

                2
            

            

                
    Message {

            

        

            

                35
            

            

                2
            

            

                
        contents: String::from(value),

            

        

            

                36
            

            

                2
            

            

                
        timestamp: SystemTime::now(),

            

        

            

                37
            

            

                2
            

            

                
    }

            

        

            

                38
            

            

                2
            

            

                
    .push_into(connection)?;

            

        

            

                39
            

            

                2
            

            

                
    Ok(())

            

        

            

                40
            

            

                2
            

            

                
}

            

        

            

                41
            

            

                
            

            

                
// ANCHOR_END: reusable-code

            

        

            

                42
            

            

                
            

            

                

            

        

            

                43
            

            

                1
            

            

                
#[test]

            

        

            

                44
            

            

                1
            

            

                
fn runs() {

            

        

            

                45
            

            

                1
            

            

                
    main().unwrap()

            

        

            

                46
            

            

                1
            

            

                
}