ormdantic-schema 2.0.1

Schema metadata structures for Ormdantic
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

use ormdantic_schema::{ColumnDef, ColumnDefault, ComputedDef, FieldKind, IdentityDef};

#[test]
fn column_builder_exposes_all_options() {
    let identity = IdentityDef::new()
        .start(10)
        .increment(5)
        .min_value(1)
        .max_value(1000)
        .no_min_value(false)
        .no_max_value(false)
        .cycle(true)
        .cache(20)
        .order(true)
        .on_null(true)
        .always(true);
    let computed = ComputedDef::new("price * quantity").persisted(true);
    let column = ColumnDef::new("total", FieldKind::Decimal)
        .nullable(true)
        .primary_key(true)
        .default(ColumnDefault::Expression("0".to_string()))
        .with_server_default("0")
        .with_identity(identity.clone())
        .with_computed(computed.clone())
        .autoincrement(true)
        .with_collation("NOCASE")
        .with_comment("computed total")
        .numeric(12, 2)
        .with_max_length(255)
        .with_sqlite_on_conflict_primary_key("REPLACE")
        .with_sqlite_on_conflict_not_null("FAIL")
        .with_sqlite_on_conflict_unique("IGNORE");

    assert_eq!(column.name(), "total");
    assert_eq!(column.kind(), &FieldKind::Decimal);
    assert!(column.is_nullable());
    assert!(column.is_primary_key());
    assert_eq!(
        column.default_value(),
        Some(&ColumnDefault::Expression("0".to_string()))
    );
    assert_eq!(column.server_default(), Some("0"));
    assert_eq!(column.identity(), Some(&identity));
    assert_eq!(identity.minimum_value(), Some(1));
    assert_eq!(identity.maximum_value(), Some(1000));
    assert!(!identity.is_no_min_value());
    assert!(!identity.is_no_max_value());
    assert!(identity.is_cycle());
    assert_eq!(identity.cache_value(), Some(20));
    assert!(identity.is_ordered());
    assert!(identity.is_on_null());
    assert_eq!(column.computed(), Some(&computed));
    assert!(column.is_autoincrement());
    assert_eq!(column.collation(), Some("NOCASE"));
    assert_eq!(column.comment(), Some("computed total"));
    assert_eq!(column.precision(), Some(12));
    assert_eq!(column.scale(), Some(2));
    assert_eq!(column.max_length(), Some(255));
    assert_eq!(column.sqlite_on_conflict_primary_key(), Some("REPLACE"));
    assert_eq!(column.sqlite_on_conflict_not_null(), Some("FAIL"));
    assert_eq!(column.sqlite_on_conflict_unique(), Some("IGNORE"));
}

#[test]
fn identity_and_computed_defaults_are_minimal() {
    let identity = IdentityDef::default();
    let computed = ComputedDef::new("lower(name)");

    assert_eq!(identity.start_value(), None);
    assert_eq!(identity.increment_value(), None);
    assert_eq!(identity.minimum_value(), None);
    assert_eq!(identity.maximum_value(), None);
    assert!(!identity.is_no_min_value());
    assert!(!identity.is_no_max_value());
    assert_eq!(identity.cache_value(), None);
    assert!(!identity.is_always());
    assert!(!identity.is_cycle());
    assert!(!identity.is_ordered());
    assert!(!identity.is_on_null());
    assert_eq!(computed.expression(), "lower(name)");
    assert!(!computed.is_persisted());
}

#[test]
fn identity_builder_exposes_no_bound_flags() {
    let identity = IdentityDef::new().no_min_value(true).no_max_value(true);

    assert!(identity.is_no_min_value());
    assert!(identity.is_no_max_value());
    assert_eq!(identity.minimum_value(), None);
    assert_eq!(identity.maximum_value(), None);
}

#[test]
fn column_builder_accepts_sqlite_conflict_options() {
    let column = ColumnDef::new("name", FieldKind::String)
        .with_sqlite_on_conflict_primary_key_option(Some("ROLLBACK".to_string()))
        .with_sqlite_on_conflict_not_null_option(Some("ABORT".to_string()))
        .with_sqlite_on_conflict_unique_option(Some("FAIL".to_string()));

    assert_eq!(column.sqlite_on_conflict_primary_key(), Some("ROLLBACK"));
    assert_eq!(column.sqlite_on_conflict_not_null(), Some("ABORT"));
    assert_eq!(column.sqlite_on_conflict_unique(), Some("FAIL"));

    let cleared = column
        .with_sqlite_on_conflict_primary_key_option(None)
        .with_sqlite_on_conflict_not_null_option(None)
        .with_sqlite_on_conflict_unique_option(None);

    assert_eq!(cleared.sqlite_on_conflict_primary_key(), None);
    assert_eq!(cleared.sqlite_on_conflict_not_null(), None);
    assert_eq!(cleared.sqlite_on_conflict_unique(), None);
}