sqlx 0.8.6

🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and 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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use criterion::BenchmarkId;
use criterion::Criterion;
use criterion::{criterion_group, criterion_main};

use sqlx::sqlite::{Sqlite, SqliteConnection};
use sqlx::{Connection, Executor};
use sqlx_test::new;

// Here we have an async function to benchmark
async fn do_describe_trivial(db: &std::cell::RefCell<SqliteConnection>) {
    db.borrow_mut().describe("select 1").await.unwrap();
}

async fn do_describe_recursive(db: &std::cell::RefCell<SqliteConnection>) {
    db.borrow_mut()
        .describe(
            r#"
            WITH RECURSIVE schedule(begin_date) AS MATERIALIZED (
                SELECT datetime('2022-10-01')
                WHERE datetime('2022-10-01') < datetime('2022-11-03')
                UNION ALL
                SELECT datetime(begin_date,'+1 day')
                FROM schedule
                WHERE datetime(begin_date) < datetime(?2)
            )
            SELECT
            begin_date
            FROM schedule
            GROUP BY begin_date
            "#,
        )
        .await
        .unwrap();
}

async fn do_describe_insert(db: &std::cell::RefCell<SqliteConnection>) {
    db.borrow_mut()
        .describe("INSERT INTO tweet (id, text) VALUES (2, 'Hello') RETURNING *")
        .await
        .unwrap();
}

async fn do_describe_insert_fks(db: &std::cell::RefCell<SqliteConnection>) {
    db.borrow_mut()
        .describe("insert into statements (text) values ('a') returning id")
        .await
        .unwrap();
}

async fn init_connection() -> SqliteConnection {
    let mut conn = new::<Sqlite>().await.unwrap();

    conn.execute(
        r#"
        CREATE TEMPORARY TABLE statements (
          id integer not null primary key,
          text text not null
        );

        CREATE TEMPORARY TABLE votes1 (statement_id integer not null references statements(id));
        CREATE TEMPORARY TABLE votes2 (statement_id integer not null references statements(id));
        CREATE TEMPORARY TABLE votes3 (statement_id integer not null references statements(id));
        CREATE TEMPORARY TABLE votes4 (statement_id integer not null references statements(id));
        CREATE TEMPORARY TABLE votes5 (statement_id integer not null references statements(id));
        CREATE TEMPORARY TABLE votes6 (statement_id integer not null references statements(id));
        --CREATE TEMPORARY TABLE votes7 (statement_id integer not null references statements(id));
        --CREATE TEMPORARY TABLE votes8 (statement_id integer not null references statements(id));
        --CREATE TEMPORARY TABLE votes9 (statement_id integer not null references statements(id));
        --CREATE TEMPORARY TABLE votes10 (statement_id integer not null references statements(id));
        --CREATE TEMPORARY TABLE votes11 (statement_id integer not null references statements(id));
    "#,
    )
    .await
    .unwrap();
    conn
}

fn describe_trivial(c: &mut Criterion) {
    let runtime = tokio::runtime::Runtime::new().unwrap();
    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));

    c.bench_with_input(
        BenchmarkId::new("select", "trivial"),
        &db,
        move |b, db_ref| {
            // Insert a call to `to_async` to convert the bencher to async mode.
            // The timing loops are the same as with the normal bencher.
            b.to_async(&runtime).iter(|| do_describe_trivial(db_ref));
        },
    );
}

fn describe_recursive(c: &mut Criterion) {
    let runtime = tokio::runtime::Runtime::new().unwrap();
    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));

    c.bench_with_input(
        BenchmarkId::new("select", "recursive"),
        &db,
        move |b, db_ref| {
            // Insert a call to `to_async` to convert the bencher to async mode.
            // The timing loops are the same as with the normal bencher.
            b.to_async(&runtime).iter(|| do_describe_recursive(db_ref));
        },
    );
}

fn describe_insert(c: &mut Criterion) {
    let runtime = tokio::runtime::Runtime::new().unwrap();
    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));

    c.bench_with_input(
        BenchmarkId::new("insert", "returning"),
        &db,
        move |b, db_ref| {
            // Insert a call to `to_async` to convert the bencher to async mode.
            // The timing loops are the same as with the normal bencher.
            b.to_async(&runtime).iter(|| do_describe_insert(db_ref));
        },
    );
}

fn describe_insert_fks(c: &mut Criterion) {
    let runtime = tokio::runtime::Runtime::new().unwrap();
    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));

    c.bench_with_input(BenchmarkId::new("insert", "fks"), &db, move |b, db_ref| {
        // Insert a call to `to_async` to convert the bencher to async mode.
        // The timing loops are the same as with the normal bencher.
        b.to_async(&runtime).iter(|| do_describe_insert_fks(db_ref));
    });
}

criterion_group!(
    benches,
    describe_trivial,
    describe_recursive,
    describe_insert,
    describe_insert_fks
);
criterion_main!(benches);