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

use sql_orm::prelude::*;
use sql_orm::query::{Expr, Predicate};

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

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

#[derive(Entity, Debug, Clone)]
#[orm(table = "todo_items", schema = "todo")]
struct TodoItem {
    #[orm(primary_key)]
    #[orm(identity)]
    id: i64,
    list_id: i64,
    completed_by_user_id: Option<i64>,
    title: String,
    position: i32,
    is_completed: bool,
}

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

fn accept_item_query(_query: DbSetQuery<TodoItem>) {}
fn accept_list_query(_query: DbSetQuery<TodoList>) {}

async fn count_open_items(db: &TodoAppDbContext) -> Result<i64, OrmError> {
    db.todo_items
        .query()
        .filter(
            TodoItem::list_id
                .eq(9_i64)
                .and(TodoItem::is_completed.eq(false)),
        )
        .count()
        .await
}

fn main() {
    let _build_queries = |db: &TodoAppDbContext| {
        accept_list_query(
            db.todo_lists
                .query()
                .filter(
                    TodoList::owner_user_id
                        .eq(7_i64)
                        .and(TodoList::is_archived.eq(false)),
                )
                .order_by(TodoList::title.asc())
                .paginate(PageRequest::new(2, 10)),
        );

        accept_item_query(
            db.todo_items
                .query()
                .inner_join::<TodoList>(Predicate::eq(
                    Expr::from(TodoItem::list_id),
                    Expr::from(TodoList::id),
                ))
                .left_join::<User>(Predicate::eq(
                    Expr::from(TodoItem::completed_by_user_id),
                    Expr::from(User::id),
                ))
                .filter(
                    TodoList::owner_user_id
                        .eq(7_i64)
                        .and(TodoItem::is_completed.eq(false)),
                )
                .order_by(TodoItem::position.asc())
                .limit(20),
        );

        accept_item_query(
            db.todo_items
                .query()
                .filter(TodoItem::list_id.eq(5_i64))
                .order_by(TodoItem::position.asc())
                .take(5),
        );
    };

    let _count_open_items = count_open_items;
}