serde-sqlx 0.0.1

Allows deserializing Postgres rows into Rust types using serde
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

mod util;

use serde::Deserialize;
use util::{fetch_all, fetch_one};

#[derive(Debug, Deserialize, PartialEq)]
pub struct QueryStats {
    pub query: String,
    pub calls: i64,
    pub total_exec_time: f64,
    pub mean_exec_time: f64,
    pub rows: i64,
    pub total_blocks: i64,
}

#[tokio::test]
async fn test_single_query_stats() {
    // Test that a single row can be fetched and deserialized into QueryStats.
    let stats: QueryStats = fetch_one(
        r#"
            SELECT
                'dummy query' AS query,
                10 AS calls,
                123.45 AS total_exec_time,
                12.34 AS mean_exec_time,
                100 AS rows,
                256 AS total_blocks
        "#,
    )
    .await
    .unwrap();

    assert_eq!(
        stats,
        QueryStats {
            query: "dummy query".to_owned(),
            calls: 10,
            total_exec_time: 123.45,
            mean_exec_time: 12.34,
            rows: 100,
            total_blocks: 256,
        }
    );
}

#[tokio::test]
async fn test_multiple_query_stats() {
    // Test that multiple rows can be fetched and deserialized into a Vec<QueryStats>.
    let rows: Vec<QueryStats> = fetch_all(
        r#"
            SELECT * FROM (
                SELECT 'query1' AS query, 5 AS calls, 200.0 AS total_exec_time, 40.0 AS mean_exec_time, 50 AS rows, 300 AS total_blocks
                UNION ALL
                SELECT 'query2', 15, 400.0, 26.67, 80, 500
            ) T
        "#,
    )
    .await
    .unwrap();

    assert_eq!(
        rows,
        vec![
            QueryStats {
                query: "query1".to_owned(),
                calls: 5,
                total_exec_time: 200.0,
                mean_exec_time: 40.0,
                rows: 50,
                total_blocks: 300,
            },
            QueryStats {
                query: "query2".to_owned(),
                calls: 15,
                total_exec_time: 400.0,
                mean_exec_time: 26.67,
                rows: 80,
                total_blocks: 500,
            },
        ]
    );
}

#[tokio::test]
async fn test_query_stats_from_json_field() -> anyhow::Result<()> {
    // Test deserializing a JSON field into an inner QueryStats struct.
    #[derive(Debug, Deserialize, PartialEq)]
    struct Wrapper {
        query_stats: QueryStats,
    }

    let out: Vec<Wrapper> = fetch_all(
        r#"
            SELECT row_to_json(q) AS query_stats FROM (
                SELECT
                    'dummy query' AS query,
                    10 AS calls,
                    123.45 AS total_exec_time,
                    12.34 AS mean_exec_time,
                    100 AS rows,
                    256 AS total_blocks
            ) q
        "#,
    )
    .await?;

    assert_eq!(
        out,
        vec![Wrapper {
            query_stats: QueryStats {
                query: "dummy query".to_owned(),
                calls: 10,
                total_exec_time: 123.45,
                mean_exec_time: 12.34,
                rows: 100,
                total_blocks: 256,
            }
        }]
    );

    Ok(())
}