# semilattice-database-session

## Example

```rust
use std::{num::NonZeroU32, sync::Arc};

use hashbrown::HashMap;
use semilattice_database::FieldName;
use semilattice_database_session::*;

let dir = "./sl-test/";

if std::path::Path::new(dir).exists() {
    std::fs::remove_dir_all(dir).unwrap();
}
std::fs::create_dir_all(dir).unwrap();

let mut database = SessionDatabase::new(dir.into(), None, 10);

let collection_admin = database.collection_id_or_create("admin");

let field_id = FieldName::new("id".into());
let field_password = FieldName::new("password".into());

let mut sess = database.session("creatre_account_1st", None);
futures::executor::block_on(async {
    database
        .update(
            &mut sess,
            vec![SessionRecord::Update {
                collection_id: collection_admin,
                row: None,
                activity: Activity::Active,
                term_begin: Default::default(),
                term_end: Default::default(),
                fields: [
                    (field_id.clone(), b"test".to_vec()),
                    (field_password.clone(), b"test".to_vec()),
                ]
                .into(),
                depends: Depends::Overwrite(vec![]),
                pends: vec![],
            }],
        )
        .await;
    database.commit(&mut sess).await;

    let collection_login = database.collection_id_or_create("login");
    let mut sess = database.session("login", None);

    let search = database
        .search(collection_admin)
        .search_field(field_id.clone(), search::Field::Match(b"test".to_vec()))
        .search_field(
            field_password.clone(),
            search::Field::Match(b"test".to_vec()),
        );

    for row in sess
        .result_with(&search.result(&database).await)
        .await
        .rows()
    {
        database
            .update(
                &mut sess,
                vec![SessionRecord::Update {
                    collection_id: collection_login,
                    row: None,
                    activity: Activity::Active,
                    term_begin: Default::default(),
                    term_end: Default::default(),
                    fields: HashMap::new(),
                    depends: Depends::Overwrite(vec![(
                        Arc::new("admin".into()),
                        CollectionRow::new(collection_admin, (*row).try_into().unwrap()),
                    )]),
                    pends: vec![],
                }],
            )
            .await;
    }
    let search = database.search(collection_login);
    for row in sess
        .result_with(&search.result(&database).await)
        .await
        .rows()
    {
        println!("depends_with_session {} {}", collection_login, row);
        let depends = database.depends_with_session(
            Some(Arc::new("admin".into())),
            collection_login,
            (*row).try_into().unwrap(),
            Some(&sess),
        );
        for d in depends {
            let collection_id = d.collection_id();
            if let Some(collection) = database.collection(collection_id) {
                let search = database
                    .search(collection_id)
                    .search_row(search::Number::In(vec![d.row().get() as isize]));
                for row in sess
                    .result_with(&search.result(&database).await)
                    .await
                    .rows()
                {
                    println!(
                        "login id : {}",
                        std::str::from_utf8(
                            collection.field_bytes((*row).try_into().unwrap(), &field_id)
                        )
                        .unwrap()
                    );
                }
            }
        }
    }

    let collection_person = database.collection_id_or_create("person");
    let collection_history = database.collection_id_or_create("history");

    let field_name = FieldName::new("name".into());
    let field_birthday = FieldName::new("birthday".into());

    let field_date = FieldName::new("date".into());
    let field_event = FieldName::new("event".into());

    let mut sess = database.session("test", None);
    database
        .update(
            &mut sess,
            vec![
                SessionRecord::Update {
                    collection_id: collection_person,
                    row: None,
                    activity: Activity::Active,
                    term_begin: Default::default(),
                    term_end: Default::default(),
                    fields: [
                        (field_name.clone(), "Joe".into()),
                        (field_birthday.clone(), "1972-08-02".into()),
                    ]
                    .into(),
                    depends: Depends::Overwrite(vec![]),
                    pends: vec![Pend {
                        key: Arc::new("history".into()),
                        records: vec![
                            SessionRecord::Update {
                                collection_id: collection_history,
                                row: None,
                                activity: Activity::Active,
                                term_begin: Default::default(),
                                term_end: Default::default(),
                                fields: [
                                    (field_date.clone(), "1972-08-02".into()),
                                    (field_event.clone(), "Birth".into()),
                                ]
                                .into(),
                                depends: Depends::Default,
                                pends: vec![],
                            },
                            SessionRecord::Update {
                                collection_id: collection_history,
                                row: None,
                                activity: Activity::Active,
                                term_begin: Default::default(),
                                term_end: Default::default(),
                                fields: [
                                    (field_date.clone(), "1999-12-31".into()),
                                    (field_event.clone(), "Mariage".into()),
                                ]
                                .into(),
                                depends: Depends::Default,
                                pends: vec![],
                            },
                        ],
                    }],
                },
                SessionRecord::Update {
                    collection_id: collection_person,
                    row: None,
                    activity: Activity::Active,
                    term_begin: Default::default(),
                    term_end: Default::default(),
                    fields: [
                        (field_name.clone(), "Tom".into()),
                        (field_birthday.clone(), "2000-12-12".into()),
                    ]
                    .into(),
                    depends: Depends::Default,
                    pends: vec![Pend {
                        key: Arc::new("history".into()),
                        records: vec![SessionRecord::Update {
                            collection_id: collection_history,
                            row: None,
                            activity: Activity::Active,
                            term_begin: Default::default(),
                            term_end: Default::default(),
                            fields: [
                                (field_date.clone(), "2000-12-12".into()),
                                (field_event.clone(), "Birth".into()),
                            ]
                            .into(),
                            depends: Depends::Default,
                            pends: vec![],
                        }],
                    }],
                },
                SessionRecord::Update {
                    collection_id: collection_person,
                    row: None,
                    activity: Activity::Active,
                    term_begin: Default::default(),
                    term_end: Default::default(),
                    fields: [
                        (field_name.clone(), "Billy".into()),
                        (field_birthday.clone(), "1982-03-03".into()),
                    ]
                    .into(),
                    depends: Depends::Default,
                    pends: vec![],
                },
            ],
        )
        .await;
    database.commit(&mut sess).await;

    if let (Some(person), Some(history)) = (
        database.collection(collection_person),
        database.collection(collection_history),
    ) {
        let person_rows = database
            .search(collection_person)
            .result(&database)
            .await
            .sort(
                &database,
                &vec![Order::Asc(OrderKey::Field(field_birthday.clone()))],
            );
        for i in person_rows {
            println!(
                "{},{}",
                std::str::from_utf8(person.field_bytes(i, &field_name)).unwrap(),
                std::str::from_utf8(person.field_bytes(i, &field_birthday)).unwrap()
            );
            for h in database
                .search(collection_history)
                .search(Condition::Depend(
                    Some(Arc::new("history".into())),
                    CollectionRow::new(collection_person, i),
                ))
                .result(&database)
                .await
                .rows()
            {
                println!(
                    " {} : {}",
                    std::str::from_utf8(history.field_bytes(*h, &field_date)).unwrap(),
                    std::str::from_utf8(history.field_bytes(*h, &field_event)).unwrap()
                );
            }
        }
    }
    let mut sess = database.session("test", None);
    database
        .update(
            &mut sess,
            vec![SessionRecord::Update {
                collection_id: collection_person,
                row: NonZeroU32::new(1),
                activity: Activity::Active,
                term_begin: Default::default(),
                term_end: Default::default(),
                fields: [(field_name.clone(), "Renamed Joe".into())].into(),
                depends: Depends::Default,
                pends: vec![],
            }],
        )
        .await;

    let mut sess = database.session("test", None);
    let search = database
        .search(collection_person)
        .search_activity(Activity::Active);
    for r in sess
        .result_with(&search.result(&database).await)
        .await
        .rows()
    {
        println!(
            "session_search : {},{}",
            std::str::from_utf8(sess.field_bytes(
                &database,
                collection_person,
                *r,
                &field_name
            ))
            .unwrap(),
            std::str::from_utf8(sess.field_bytes(
                &database,
                collection_person,
                *r,
                &field_birthday
            ))
            .unwrap()
        );
    }
    database.commit(&mut sess).await;

    let test1 = database.collection_id_or_create("test1");

    let field_num = FieldName::new("num".into());
    let field_num_by3 = FieldName::new("num_by3".into());

    let range = 1u32..=10;
    let mut sess = database.session("test", None);
    for i in range.clone() {
        database
            .update(
                &mut sess,
                vec![SessionRecord::Update {
                    collection_id: test1,
                    row: None,
                    activity: Activity::Active,
                    term_begin: Default::default(),
                    term_end: Default::default(),
                    fields: [
                        (field_num.clone(), i.to_string().into()),
                        (field_num_by3.clone(), (i * 3).to_string().into()),
                    ]
                    .into(),
                    depends: Depends::Overwrite(vec![]),
                    pends: vec![],
                }],
            )
            .await;
    }
    database.commit(&mut sess).await;

    let mut sess = database.session("test", None);
    database
        .update(
            &mut sess,
            vec![SessionRecord::Update {
                collection_id: test1,
                row: NonZeroU32::new(3),
                activity: Activity::Active,
                term_begin: Default::default(),
                term_end: Default::default(),
                fields: HashMap::new(),
                depends: Depends::Overwrite(vec![]),
                pends: vec![],
            }],
        )
        .await;
    database.commit(&mut sess).await;

    if let Some(t1) = database.collection(test1) {
        let mut sum = 0.0;
        for i in range.clone() {
            sum += t1.field_num(i.try_into().unwrap(), &field_num);
            println!(
                "{},{},{},{},{},{},{},{}",
                t1.serial(i.try_into().unwrap()),
                if let Some(Activity::Active) = t1.activity(i.try_into().unwrap()) {
                    "Active"
                } else {
                    "Inactive"
                },
                t1.uuid_string(i.try_into().unwrap())
                    .unwrap_or("".to_string()),
                t1.last_updated(i.try_into().unwrap()).unwrap_or(0),
                t1.term_begin(i.try_into().unwrap()).unwrap_or(0),
                t1.term_end(i.try_into().unwrap()).unwrap_or(0),
                std::str::from_utf8(t1.field_bytes(i.try_into().unwrap(), &field_num)).unwrap(),
                std::str::from_utf8(t1.field_bytes(i.try_into().unwrap(), &field_num_by3))
                    .unwrap()
            );
        }
        assert_eq!(sum, 55.0);
    }
});
```