welds 0.5.0

An async ORM for (postgres, mssql, mysql, sqlite)
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

use crate::Syntax;
use crate::migrations::create_table::ColumnBuilder;
use crate::migrations::types::Index;
use crate::migrations::types::OnDelete;
use crate::model_traits::TableIdent;
use crate::writers::ColumnWriter;
use crate::writers::TableWriter;

pub fn write(syntax: Syntax, table: &TableIdent, col: &ColumnBuilder) -> String {
    let tablename = TableWriter::new(syntax).write(table);
    let colname = ColumnWriter::new(syntax).excape(col.name.as_str());

    let indexname = match &col.index_name {
        Some(n) => n.to_owned(),
        None => format!("ix_{}_{}", table.name, col.name),
    };

    let index = match &col.index {
        Some(i) => i,
        None => return "".to_owned(),
    };

    match index {
        Index::Unique => format!("CREATE UNIQUE INDEX {indexname} ON {tablename} ( {colname} )"),
        Index::Default => format!("CREATE INDEX {indexname} ON {tablename} ( {colname} )"),
        Index::ForeignKey((f_table, f_column, on_delete)) => {
            write_fk(syntax, table, col, f_table, f_column, *on_delete)
        }
    }
}

/// write the fk creation for sqlite. inline while table is being created
pub(crate) fn write_inline_fk(syntax: Syntax, col: &ColumnBuilder) -> Option<String> {
    // only sqlite needs FKs create in the table create
    if syntax != Syntax::Sqlite {
        return None;
    }

    // pull out the info about the FK to create
    let colname = ColumnWriter::new(syntax).excape(col.name.as_str());
    let (f_table, f_column, on_delete) = match col.index.as_ref()? {
        Index::ForeignKey(fk_args) => fk_args,
        _ => return None,
    };
    let f_column = ColumnWriter::new(syntax).excape(f_column.as_str());

    let on_delete_str = match on_delete {
        OnDelete::Cascade => "CASCADE",
        OnDelete::SetNull => "SET NULL",
        OnDelete::SetDefault => "SET DEFAULT",
        OnDelete::Restrict => "RESTRICT",
        OnDelete::NoAction => "NO ACTION",
    };

    Some(format!(
        "FOREIGN KEY ({colname}) REFERENCES {f_table}({f_column}) ON DELETE {on_delete_str}"
    ))
}

fn write_fk(
    syntax: Syntax,
    table: &TableIdent,
    col: &ColumnBuilder,
    foreign_table: &str,
    foreign_column: &str,
    on_delete: OnDelete,
) -> String {
    if syntax == Syntax::Sqlite {
        return String::default();
    }

    let on_delete_str = match on_delete {
        OnDelete::Cascade => "CASCADE",
        OnDelete::SetNull => "SET NULL",
        OnDelete::SetDefault => "SET DEFAULT",
        OnDelete::Restrict => "RESTRICT",
        OnDelete::NoAction => "NO ACTION",
    };

    let indexname = match &col.index_name {
        Some(n) => n.to_owned(),
        None => format!("fk_{}_{}", table.name, col.name),
    };

    let tablename = TableWriter::new(syntax).write(table);
    let colname = ColumnWriter::new(syntax).excape(col.name.as_str());
    let foreign_column = ColumnWriter::new(syntax).excape(foreign_column);

    format!(
        "ALTER TABLE {tablename} ADD CONSTRAINT {indexname} FOREIGN KEY ({colname}) REFERENCES {foreign_table} ({foreign_column}) ON DELETE {on_delete_str}"
    )
}