helge 3.0.0

Tiny wrapper around r2d2::Pool and diesel ConnectionManager to ease use in async contexts
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

use diesel::r2d2::{ConnectionManager, ManageConnection};
use helge::Helge;

extern crate diesel;

use diesel::prelude::*;

#[rustfmt::skip]
table! {
    users {
	id -> Integer,
	name -> Varchar,
    }
}

#[derive(Debug, Insertable)]
#[diesel(table_name = users)]
struct NewUser {
    name: String,
}

#[tokio::main]
async fn main() {
    let database_url = "postgres://localhost/helgeexample";

    let connection_manager = ConnectionManager::<diesel::PgConnection>::new(database_url);
    let mut conn = connection_manager.connect().expect("Connecting");
    diesel::sql_query("DROP TABLE IF EXISTS users")
        .execute(&mut conn)
        .expect("dropping table `users`");

    diesel::sql_query(
        "CREATE TABLE IF NOT EXISTS users(id SERIAL PRIMARY KEY, name VARCHAR NOT NULL)",
    )
    .execute(&mut conn)
    .expect("creating table `users`");

    // Create Helge from a Builder, allowing custimization of the Pool.
    let pool = diesel::r2d2::Builder::new()
        .build(connection_manager)
        .expect("Building r2d2 pool");

    let pool = Helge::from_pool(pool);

    pool.query(|conn| {
        diesel::insert_into(users::table)
            .values(&NewUser {
                name: String::from("Helge"),
            })
            .execute(conn)
    })
    .await
    .expect("inserting users");

    let helge = pool
        .query(|conn| users::table.get_results::<(i32, String)>(conn))
        .await
        .expect("reading users");

    println!("Fetched {:?}", helge);
}