welds-connections 0.4.23

An async ORM for (postgres, mssql, 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
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

use super::Row;
use super::{Client, Param};
use crate::errors::Result;
use crate::{ExecuteResult, Syntax};
use async_trait::async_trait;
use std::sync::{Arc, Mutex};

#[cfg(feature = "unstable-api")]
use crate::StreamClient;
#[cfg(feature = "unstable-api")]
use futures_core::stream::BoxStream;

// This is a version of a client that does nothing.
// It is used for testing
//
// You can change its syntax and get the last SQL that we "ran"
#[derive(Clone)]
pub struct NoopClient {
    syntax: Syntax,
    last_sql: Arc<Mutex<Option<String>>>,
    args_count: Arc<Mutex<Option<u64>>>,
}

pub fn build(syntax: Syntax) -> NoopClient {
    NoopClient {
        syntax,
        last_sql: Arc::new(Mutex::new(None)),
        args_count: Arc::new(Mutex::new(None)),
    }
}

impl NoopClient {
    pub fn set_syntax(&mut self, syntax: Syntax) {
        self.syntax = syntax;
    }

    pub fn last_sql(&self) -> Option<String> {
        let lock = self.last_sql.clone();
        let mutex = lock.lock().unwrap();
        mutex.clone()
    }

    pub fn args_count(&self) -> Option<u64> {
        let lock = self.args_count.clone();
        let mutex = lock.lock().unwrap();
        *mutex
    }
}

#[async_trait]
impl Client for NoopClient {
    async fn execute(&self, sql: &str, params: &[&(dyn Param + Sync)]) -> Result<ExecuteResult> {
        // save off the sql
        let lock = self.last_sql.clone();
        let mut mutex = lock.lock().unwrap();
        *mutex = Some(sql.to_string());

        // save off the args count
        let lock = self.args_count.clone();
        let mut mutex = lock.lock().unwrap();
        *mutex = Some(params.len() as u64);

        // return nothing
        Ok(ExecuteResult { rows_affected: 0 })
    }

    async fn fetch_rows(&self, sql: &str, params: &[&(dyn Param + Sync)]) -> Result<Vec<Row>> {
        // save off the sql
        let lock = self.last_sql.clone();
        let mut mutex = lock.lock().unwrap();
        *mutex = Some(sql.to_string());

        // save off the args count
        let lock = self.args_count.clone();
        let mut mutex = lock.lock().unwrap();
        *mutex = Some(params.len() as u64);

        // return nothing
        Ok(Vec::default())
    }

    async fn fetch_many<'s, 'args, 'i>(
        &self,
        fetches: &[crate::Fetch<'s, 'args, 'i>],
    ) -> Result<Vec<Vec<Row>>> {
        let mut total = 0;
        let mut sqls = Vec::default();
        for fetch in fetches {
            sqls.push(fetch.sql);
            total += fetch.params.len()
        }

        // save off the sql
        let lock = self.last_sql.clone();
        let mut mutex = lock.lock().unwrap();
        *mutex = Some(sqls.join(";").to_string());

        // save off the args count
        let lock = self.args_count.clone();
        let mut mutex = lock.lock().unwrap();
        *mutex = Some(total as u64);

        Ok(Vec::default())
    }

    fn syntax(&self) -> crate::Syntax {
        self.syntax
    }
}

#[cfg(feature = "unstable-api")]
#[async_trait]
impl StreamClient for NoopClient {
    /// Run the SQL streaming the results back in a future::stream
    async fn stream<'client, 'e, 'params>(
        &'client self,
        _sql: &str,
        _params: &[&'params (dyn Param + Sync)],
    ) -> BoxStream<'e, Result<Row>>
    where
        'client: 'e,
        'params: 'e,
    {
        use futures::StreamExt;
        futures::stream::iter([]).boxed()
    }
}