sql-orm 0.1.0

Public API crate for the sql-orm workspace.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use sql_orm::prelude::*;

#[derive(Entity, Debug, Clone)]
#[orm(table = "users", schema = "todo")]
struct User {
    #[orm(primary_key)]
    #[orm(identity)]
    id: i64,

    #[orm(length = 180)]
    #[orm(unique)]
    email: String,

    #[orm(nullable)]
    display_name: Option<String>,

    #[orm(rowversion)]
    version: Vec<u8>,
}

#[derive(Entity, Debug, Clone)]
#[orm(table = "todo_lists", schema = "todo")]
struct TodoList {
    #[orm(primary_key)]
    #[orm(identity)]
    id: i64,

    #[orm(foreign_key(entity = User, column = id))]
    #[orm(on_delete = "cascade")]
    owner_user_id: i64,

    #[orm(length = 160)]
    title: String,
}

#[derive(Insertable, Debug, Clone)]
#[orm(entity = User)]
struct NewUser {
    email: String,
    display_name: Option<String>,
}

#[derive(Changeset, Debug, Clone)]
#[orm(entity = User)]
struct UpdateUser {
    email: Option<String>,
    display_name: Option<Option<String>>,
}

#[derive(DbContext, Debug, Clone)]
struct TodoDb {
    pub users: DbSet<User>,
    pub todo_lists: DbSet<TodoList>,
}

async fn code_first_flow(db: &TodoDb) -> Result<(), OrmError> {
    let inserted = db
        .users
        .insert(NewUser {
            email: "ana@example.com".to_string(),
            display_name: Some("Ana".to_string()),
        })
        .await?;

    let _found = db.users.find(inserted.id).await?;

    let _users = db
        .users
        .query()
        .filter(User::email.contains("@example.com"))
        .order_by(User::email.asc())
        .take(20)
        .all()
        .await?;

    let _updated = db
        .users
        .update(
            inserted.id,
            UpdateUser {
                email: None,
                display_name: Some(Some("Ana Maria".to_string())),
            },
        )
        .await?;

    let _deleted = db.users.delete(inserted.id).await?;

    Ok(())
}

fn main() {
    let user_metadata = User::metadata();
    let list_metadata = TodoList::metadata();

    assert_eq!(user_metadata.schema, "todo");
    assert_eq!(user_metadata.table, "users");
    assert_eq!(user_metadata.primary_key.columns, &["id"]);
    assert_eq!(list_metadata.foreign_keys.len(), 1);

    let _connect = TodoDb::connect;
    let _connect_with_options = TodoDb::connect_with_options;
    let _connect_with_config = TodoDb::connect_with_config;
    let _from_connection = TodoDb::from_connection;
    let _from_shared = TodoDb::from_shared_connection;
    let _transaction = TodoDb::transaction::<
        fn(TodoDb) -> std::future::Ready<Result<(), OrmError>>,
        std::future::Ready<Result<(), OrmError>>,
        (),
    >;
    let _code_first_flow = code_first_flow;
}