a3s-orm 0.2.1

A type-safe, executor-neutral SQL query builder for Rust
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

use sha2::{Digest, Sha256};

use super::MigrationError;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Migration {
    version: String,
    name: String,
    up_sql: String,
}

impl Migration {
    pub fn new(
        version: impl Into<String>,
        name: impl Into<String>,
        up_sql: impl Into<String>,
    ) -> Self {
        Self {
            version: version.into(),
            name: name.into(),
            up_sql: up_sql.into(),
        }
    }

    pub fn version(&self) -> &str {
        &self.version
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn up_sql(&self) -> &str {
        &self.up_sql
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PreparedMigration {
    version: String,
    name: String,
    up_sql: String,
    checksum: String,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AppliedMigration {
    pub version: String,
    pub checksum: String,
}

impl PreparedMigration {
    pub(crate) fn prepare(migration: Migration) -> Self {
        let mut digest = Sha256::new();
        digest.update(migration.up_sql.as_bytes());
        let checksum = hex_encode(&digest.finalize());
        Self {
            version: migration.version,
            name: migration.name,
            up_sql: migration.up_sql,
            checksum,
        }
    }

    pub fn version(&self) -> &str {
        &self.version
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn up_sql(&self) -> &str {
        &self.up_sql
    }

    pub fn checksum(&self) -> &str {
        &self.checksum
    }
}

fn hex_encode(bytes: &[u8]) -> String {
    const HEX: &[u8; 16] = b"0123456789abcdef";
    let mut encoded = String::with_capacity(bytes.len() * 2);
    for byte in bytes {
        encoded.push(HEX[(byte >> 4) as usize] as char);
        encoded.push(HEX[(byte & 0x0f) as usize] as char);
    }
    encoded
}

pub fn pending_migrations<'a>(
    applied: &[AppliedMigration],
    source: &'a [PreparedMigration],
) -> Result<Vec<&'a PreparedMigration>, MigrationError> {
    for applied_migration in applied {
        let Some(source_migration) = source
            .iter()
            .find(|migration| migration.version() == applied_migration.version)
        else {
            return Err(MigrationError::MissingSourceMigration(
                applied_migration.version.clone(),
            ));
        };
        if source_migration.checksum() != applied_migration.checksum {
            return Err(MigrationError::ChecksumMismatch {
                version: applied_migration.version.clone(),
                applied_checksum: applied_migration.checksum.clone(),
                source_checksum: source_migration.checksum().to_owned(),
            });
        }
    }
    Ok(source
        .iter()
        .filter(|migration| {
            !applied
                .iter()
                .any(|applied| applied.version == migration.version())
        })
        .collect())
}