chain-builder 2.1.0

A typed, dialect-aware SQL query builder for Rust (PostgreSQL/MySQL/SQLite).
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

//! Row-locking clauses (`FOR UPDATE` / `FOR SHARE`, `SKIP LOCKED` / `NOWAIT`).

use chain_builder::{MySql, Postgres, QueryBuilder, Sqlite};

#[test]
fn for_update_pg() {
    let (sql, _) = QueryBuilder::<Postgres>::table("jobs")
        .select(["id"])
        .where_eq("status", "queued")
        .for_update()
        .to_sql();
    assert_eq!(
        sql,
        r#"SELECT "id" FROM "jobs" WHERE "status" = $1 FOR UPDATE"#
    );
}

#[test]
fn for_share_pg() {
    let (sql, _) = QueryBuilder::<Postgres>::table("jobs")
        .select(["id"])
        .for_share()
        .to_sql();
    assert_eq!(sql, r#"SELECT "id" FROM "jobs" FOR SHARE"#);
}

#[test]
fn for_update_skip_locked() {
    let (sql, _) = QueryBuilder::<Postgres>::table("jobs")
        .select(["id"])
        .for_update()
        .skip_locked()
        .to_sql();
    assert_eq!(sql, r#"SELECT "id" FROM "jobs" FOR UPDATE SKIP LOCKED"#);
}

#[test]
fn for_update_nowait() {
    let (sql, _) = QueryBuilder::<Postgres>::table("jobs")
        .select(["id"])
        .for_update()
        .no_wait()
        .to_sql();
    assert_eq!(sql, r#"SELECT "id" FROM "jobs" FOR UPDATE NOWAIT"#);
}

#[test]
fn skip_locked_defaults_to_for_update() {
    // Calling skip_locked() without a prior for_update()/for_share() defaults the
    // strength to FOR UPDATE (the job-queue idiom).
    let (sql, _) = QueryBuilder::<Postgres>::table("jobs")
        .select(["id"])
        .skip_locked()
        .to_sql();
    assert_eq!(sql, r#"SELECT "id" FROM "jobs" FOR UPDATE SKIP LOCKED"#);
}

#[test]
fn lock_after_limit() {
    let (sql, binds) = QueryBuilder::<Postgres>::table("jobs")
        .select(["id"])
        .limit(1)
        .for_update()
        .skip_locked()
        .to_sql();
    assert_eq!(
        sql,
        r#"SELECT "id" FROM "jobs" LIMIT $1 FOR UPDATE SKIP LOCKED"#
    );
    assert_eq!(binds.len(), 1);
}

#[test]
fn for_update_mysql() {
    let (sql, _) = QueryBuilder::<MySql>::table("jobs")
        .select(["id"])
        .for_update()
        .skip_locked()
        .to_sql();
    assert_eq!(sql, "SELECT `id` FROM `jobs` FOR UPDATE SKIP LOCKED");
}

#[test]
fn locking_is_noop_on_sqlite() {
    // SQLite locks the whole database, not rows: the clause is silently dropped.
    let (sql, _) = QueryBuilder::<Sqlite>::table("jobs")
        .select(["id"])
        .for_update()
        .skip_locked()
        .to_sql();
    assert_eq!(sql, r#"SELECT "id" FROM "jobs""#);
}

#[test]
fn for_share_then_skip_locked_preserves_strength() {
    let (sql, _) = QueryBuilder::<Postgres>::table("jobs")
        .select(["id"])
        .for_share()
        .skip_locked()
        .to_sql();
    assert_eq!(sql, r#"SELECT "id" FROM "jobs" FOR SHARE SKIP LOCKED"#);
}