datasources-sqlserver 0.1.57

sqlserver datasource stub
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

use datasources::{SqlSeedColumn, SqlSeedStatement};

pub struct SqlServerSqlSeedStatementRenderer;

impl SqlServerSqlSeedStatementRenderer {
    pub fn render(&self, statement: &SqlSeedStatement) -> String {
        let table = quote(statement.table());
        if statement.kind() == "delete" {
            let key = &statement.columns()[0];
            return format!(
                "DELETE FROM {table} WHERE {} = {}",
                quote(&key.column),
                literal(key)
            );
        }
        let cols = statement
            .columns()
            .iter()
            .map(|c| quote(&c.column))
            .collect::<Vec<_>>()
            .join(", ");
        let values = statement.columns().iter().map(literal).collect::<Vec<_>>().join(", ");
        let insert = format!("INSERT INTO {table} ({cols}) VALUES ({values})");
        if statement.identity() {
            format!("SET IDENTITY_INSERT {table} ON;\n{insert};\nSET IDENTITY_INSERT {table} OFF")
        } else {
            insert
        }
    }
}

fn quote(ident: &str) -> String {
    format!("[{ident}]")
}

fn quote_string(value: &str) -> String {
    format!("'{}'", value.replace('\'', "''"))
}

fn truthy(value: &str) -> bool {
    value == "true" || value == "True" || value == "1"
}

fn is_numeric(ty: &str) -> bool {
    matches!(
        ty,
        "integer"
            | "unsignedinteger"
            | "smallinteger"
            | "unsignedsmallinteger"
            | "biginteger"
            | "unsignedbiginteger"
            | "reference"
            | "float"
            | "decimal"
    )
}

fn default_sql(ty: &str, def: &str) -> String {
    match (ty, def) {
        ("datetime", "UtcNow") => "GETUTCDATE()".into(),
        ("datetime", "Now") => "GETDATE()".into(),
        ("uuid", "NewId") => "NEWID()".into(),
        ("boolean", text) => {
            if text == "true" || text == "True" {
                "1".into()
            } else {
                "0".into()
            }
        }
        _ => quote_string(def),
    }
}

fn literal(column: &SqlSeedColumn) -> String {
    match &column.value {
        None => column
            .field
            .default_value
            .as_deref()
            .map(|def| default_sql(&column.field.type_name, def))
            .unwrap_or_else(|| "NULL".into()),
        Some(value) if column.field.type_name == "boolean" => {
            if truthy(value) { "1".into() } else { "0".into() }
        }
        Some(value) if is_numeric(&column.field.type_name) => value.clone(),
        Some(value) if column.field.type_name == "binary" => format!("0x{value}"),
        Some(value) => quote_string(value),
    }
}