datasources 0.1.5

Async datasource interfaces, middleware, registry, and test doubles
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

use crate::i_where::IWhere;
use crate::mappers::IdentityMapper;
use crate::parameter::Parameter;
use crate::readonly_repository_statements::ReadonlyRepositoryStatements;
use crate::result::Result;
use crate::statement_mappers::StatementMappers;
use crate::statements::{
    DeleteStatement, InsertStatement, SelectInsertedIdStatement, UpdateStatement,
};
use crate::value::Value;
use std::ops::Deref;
use std::sync::Arc;

pub struct CRUDRepositoryStatements {
    read: ReadonlyRepositoryStatements,
}

impl CRUDRepositoryStatements {
    pub fn empty() -> Self {
        Self::new(
            "",
            Vec::new(),
            StatementMappers::new(
                Arc::new(IdentityMapper::<String>::new()),
                Arc::new(IdentityMapper::<String>::new()),
            ),
        )
    }

    pub fn new(
        table: impl Into<String>,
        columns: Vec<String>,
        mappings: StatementMappers,
    ) -> Self {
        Self {
            read: ReadonlyRepositoryStatements::new(table, columns, mappings),
        }
    }

    pub fn insert(&self, fields: &[Parameter]) -> InsertStatement {
        self.read
            .mappings()
            .apply_insert(&InsertStatement::new(self.table(), fields))
    }

    pub fn update(
        &self,
        fields: &[Parameter],
        where_clause: &dyn IWhere,
        cell: &dyn Fn(&str, &Value) -> Result<Value>,
    ) -> Result<UpdateStatement> {
        self.read.mappings().apply_update(
            &UpdateStatement::new(self.table(), fields, Some(where_clause)),
            cell,
        )
    }

    pub fn select_inserted_id(&self, column: &str) -> SelectInsertedIdStatement {
        self.read
            .mappings()
            .apply_inserted(&SelectInsertedIdStatement::new(self.table(), column))
    }

    pub fn delete(
        &self,
        where_clause: &dyn IWhere,
        cell: &dyn Fn(&str, &Value) -> Result<Value>,
    ) -> Result<DeleteStatement> {
        self.read.mappings().apply_delete(
            &DeleteStatement::new(self.table(), Some(where_clause)),
            cell,
        )
    }
}

impl Deref for CRUDRepositoryStatements {
    type Target = ReadonlyRepositoryStatements;

    fn deref(&self) -> &Self::Target {
        &self.read
    }
}