haro 0.3.0

A simple and synchronous web framework written in and for Rust
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

// NOTE: add `haro` crate with `full` or `database` feature flag to use database utilities.

use haro::{db, Application, Request, Response};
use mysql::prelude::*;
use serde::{Deserialize, Serialize};

fn main() {
    db::Postgres::init("postgres://postgres:postgres@localhost:5432/ci");
    db::MySQL::init("mysql://root:root@localhost:3306/test");
    db::SQLite::init("test.db");

    let mut app = Application::new("0:8080");
    app.route("/pg", pg);
    app.route("/my", my);
    app.route("/sqlite", sqlite);
    app.run();
}

#[derive(Serialize, Deserialize)]
struct Person {
    id: i32,
    name: String,
}

fn pg(_: Request) -> Response {
    let mut client = db::Postgres::get();

    // create table
    client
        .batch_execute(
            "
    CREATE TABLE IF NOT EXISTS person (
        id      SERIAL PRIMARY KEY,
        name    TEXT NOT NULL
    )
",
        )
        .unwrap();

    // insert data
    let name = "Ferris";
    client
        .execute("INSERT INTO person (name) VALUES ($1)", &[&name])
        .unwrap();

    // select data
    let mut persons = Vec::new();
    for row in client.query("SELECT id, name FROM person", &[]).unwrap() {
        let id: i32 = row.get(0);
        let name: &str = row.get(1);
        persons.push(Person {
            id,
            name: name.to_string(),
        });
    }

    Response::json(persons)
}

fn my(_: Request) -> Response {
    let mut conn = db::MySQL::get();

    // create table
    conn.query_drop(
        "
    CREATE TABLE IF NOT EXISTS person (
        id      INTEGER PRIMARY KEY,
        name    TEXT NOT NULL
    )
",
    )
    .unwrap();

    // insert data
    let name = "Ferris";
    conn.exec_drop("INSERT INTO person (name) VALUES (?)", (name,))
        .unwrap();

    // select data
    let stmt = conn.prep("SELECT id, name FROM person").unwrap();
    let persons = conn
        .exec_map(stmt, (), |(id, name)| Person { id, name })
        .unwrap();

    Response::json(persons)
}

fn sqlite(_: Request) -> Response {
    let conn = db::SQLite::get();

    // create table
    conn.execute_batch(
        "
    CREATE TABLE IF NOT EXISTS person (
        id      INTEGER PRIMARY KEY,
        name    TEXT NOT NULL
    )
",
    )
    .unwrap();

    // insert data
    let name = "Ferris";
    conn.execute("INSERT INTO person (name) VALUES ($1)", [&name])
        .unwrap();

    // select data
    let mut stmt = conn.prepare("SELECT id, name FROM person").unwrap();
    let persons: Vec<Person> = stmt
        .query_map([], |row| {
            Ok(Person {
                id: row.get(0)?,
                name: row.get(1)?,
            })
        })
        .unwrap()
        .flatten()
        .collect();

    Response::json(persons)
}