dataloom-db-core 0.9.1

A database abstraction layer
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
128
129
130
131
132
133
134

use crate::traits::from_iter::FromIter;
use crate::traits::model::Model;
use crate::traits::save_data::SaveData;
use crate::traits::save_data::ValidateSaveData;
use std::ops::Deref;

use thiserror::Error;

use crate::search::SearchQuery;

pub enum TransactionOptions {
    Commit,
    Rollback,
}

#[derive(Error, Debug)]
pub enum DatabaseStrategyError {
    #[error("Failed to migrate model: {0}")]
    MigrateModel(String),

    #[error("Failed to setup migration table: {0}")]
    MigrationTable(String),

    #[error("Failed to create transaction: {0}")]
    Transaction(String),

    #[error("Error: {0}")]
    Error(String),

    #[error("Failed to save Model <{}>: {}", .model, .err)]
    SaveModel { err: String, model: &'static str },

    #[error("Failed to search Model: {0}")]
    SearchModel(String),

    #[error("Failed to delete Model: {0}")]
    DeleteModel(String),

    #[error("Failed to parse constraints: {0}")]
    ParseConstraint(String),
}

pub trait DatabaseStrategy: Send + Sync {
    type ConnectionType<'a>: Sized + Deref<Target = Self::FunctionConnType<'a>>
    where
        Self: 'a;

    type FunctionConnType<'a>: Sized
    where
        Self: 'a;

    type TransactionType<'a>: Deref<Target = Self::FunctionConnType<'a>>
    where
        Self: 'a;

    /// This function should return a simple connection type.
    fn get_connection(&self) -> Self::ConnectionType<'_>;

    fn with_transaction<F, T>(&self, function: F) -> Result<T, DatabaseStrategyError>
    where
        F: FnOnce(Self::TransactionType<'_>) -> T;

    /// This function should tell if a table exists.
    fn table_exists(
        &self,
        conn: &Self::FunctionConnType<'_>,
        table_name: &str,
    ) -> Result<bool, DatabaseStrategyError>;

    /// This function should migrate a Model to the database.
    fn migrate_model<M: Model>(&self) -> Result<(), DatabaseStrategyError>;

    /// This function should setup the migration table.
    fn setup_migration_table(
        &self,
        conn: &Self::FunctionConnType<'_>,
    ) -> Result<(), DatabaseStrategyError>;

    /// This function should record that a migration has run.
    fn on_migration_run(
        &self,
        conn: &Self::FunctionConnType<'_>,
        table_name: &str,
        index: i64,
    ) -> Result<(), DatabaseStrategyError>;

    /// This function should return the last run migration for the given table.
    fn get_last_migration(
        &self,
        conn: &Self::FunctionConnType<'_>,
        table_name: &str,
    ) -> Result<Option<i64>, DatabaseStrategyError>;

    /// This function should save the model to the database.
    fn save_model<T>(
        &self,
        conn: &Self::FunctionConnType<'_>,
        model: &mut T,
    ) -> Result<(), DatabaseStrategyError>
    where
        T: SaveData + ValidateSaveData + Model + FromIter;

    /// This function will search for a singular model.
    fn search_single_model<T>(
        &self,
        conn: &Self::FunctionConnType<'_>,
        query: SearchQuery,
    ) -> Result<Option<T>, DatabaseStrategyError>
    where
        T: Model + FromIter;

    /// This function will search for multiple models.
    fn search_multiple_model<T>(
        &self,
        conn: &Self::FunctionConnType<'_>,
        query: SearchQuery,
    ) -> Result<Vec<T>, DatabaseStrategyError>
    where
        T: Model + FromIter;

    /// This function should remove a model from the database.
    fn remove_model<T: Model>(
        &self,
        conn: &Self::FunctionConnType<'_>,
        query: SearchQuery,
    ) -> Result<(), DatabaseStrategyError>;

    /// This function should manage a transaction connection type.
    fn manage_transaction(
        &self,
        conn: Self::TransactionType<'_>,
        options: TransactionOptions,
    ) -> Result<(), DatabaseStrategyError>;
}