tideorm 0.9.14

A developer-friendly ORM for Rust with clean, expressive syntax
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

use super::*;

impl Seeder {
    /// Ensure the seeds table exists
    pub(super) async fn ensure_seeds_table(&self) -> Result<()> {
        let database = require_db()?;
        let db_type = detect_database_type(&database);

        let sql = match db_type {
            DatabaseType::Postgres => {
                r#"
                CREATE TABLE IF NOT EXISTS "_seeds" (
                    "id" SERIAL PRIMARY KEY,
                    "name" VARCHAR(255) NOT NULL UNIQUE,
                    "executed_at" TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
                )
                "#
            }
            DatabaseType::MySQL | DatabaseType::MariaDB => {
                r#"
                CREATE TABLE IF NOT EXISTS `_seeds` (
                    `id` INT AUTO_INCREMENT PRIMARY KEY,
                    `name` VARCHAR(255) NOT NULL UNIQUE,
                    `executed_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
                )
                "#
            }
            DatabaseType::SQLite => {
                r#"
                CREATE TABLE IF NOT EXISTS "_seeds" (
                    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
                    "name" TEXT NOT NULL UNIQUE,
                    "executed_at" TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
                )
                "#
            }
        };

        database
            .__internal_connection()?
            .execute_unprepared(sql)
            .await
            .map_err(|error| Error::query(error.to_string()))?;

        Ok(())
    }

    /// Get list of executed seed names
    pub(super) async fn get_executed_seeds(&self) -> Result<Vec<String>> {
        let database = require_db()?;

        use crate::internal::build_statement;

        let backend = crate::internal::Backend::from(
            database.__internal_connection()?.get_database_backend(),
        );
        let quote = |identifier: &str| quote_ident_for_backend(backend, identifier);
        let sql = format!(
            "SELECT {} FROM {} ORDER BY {} ASC",
            quote("name"),
            quote("_seeds"),
            quote("executed_at")
        );
        let statement = build_statement(backend, sql);

        let results = database
            .__internal_connection()?
            .query_all_raw(statement)
            .await
            .map_err(|error| Error::query(error.to_string()))?;

        let mut names = Vec::new();
        for row in results {
            let name: String = row
                .try_get("", "name")
                .map_err(|error| Error::query(error.to_string()))?;
            names.push(name);
        }

        Ok(names)
    }

    /// Record a seed as executed
    pub(super) async fn record_seed(&self, name: &str) -> Result<()> {
        let database = require_db()?;
        let backend = crate::internal::Backend::from(
            database.__internal_connection()?.get_database_backend(),
        );
        let quote = |identifier: &str| quote_ident_for_backend(backend, identifier);

        let sql = format!(
            "INSERT INTO {} ({}) VALUES (?)",
            quote("_seeds"),
            quote("name")
        );

        database
            .__execute_with_params(&sql, vec![Value::String(Some(name.to_string()))])
            .await?;

        Ok(())
    }

    /// Remove a seed record
    pub(super) async fn remove_seed_record(&self, name: &str) -> Result<()> {
        let database = require_db()?;
        let backend = crate::internal::Backend::from(
            database.__internal_connection()?.get_database_backend(),
        );
        let quote = |identifier: &str| quote_ident_for_backend(backend, identifier);

        let sql = format!(
            "DELETE FROM {} WHERE {} = ?",
            quote("_seeds"),
            quote("name")
        );

        database
            .__execute_with_params(&sql, vec![Value::String(Some(name.to_string()))])
            .await?;

        Ok(())
    }
}

fn detect_database_type(database: &Database) -> DatabaseType {
    database.backend()
}