toolu-orm-core 0.1.0

Schema definitions, migrations and driver traits for toolu-orm
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

use toolu_orm_core::column::{ColumnDef, ColumnType, ForeignKeyAction};
use toolu_orm_core::dialect::Dialect;
use toolu_orm_core::diff::Operation;
use toolu_orm_core::sql::generate_sql_for;
use toolu_orm_core::table::TableDef;

#[test]
fn test_column_with_unique_constraint() {
  let ops = vec![Operation::CreateTable {
    table: TableDef {
      name: "users".to_owned(),
      columns: vec![ColumnDef {
        name: "email".to_owned(),
        column_type: ColumnType::Text,
        primary_key: false,
        not_null: true,
        default: None,
        unique: true,
        references: None,
        on_delete: None,
        on_update: None,
        check: None,
      }],
      indexes: vec![],
      strict: false,
    },
  }];
  let sql = generate_sql_for(&ops, Dialect::Sqlite);
  assert!(sql.contains("\"email\" TEXT NOT NULL UNIQUE"));
}

#[test]
fn test_column_with_references() {
  let ops = vec![Operation::CreateTable {
    table: TableDef {
      name: "messages".to_owned(),
      columns: vec![ColumnDef {
        name: "conversation_id".to_owned(),
        column_type: ColumnType::Text,
        primary_key: false,
        not_null: true,
        default: None,
        unique: false,
        references: Some("conversations(id)".to_owned()),
        on_delete: None,
        on_update: None,
        check: None,
      }],
      indexes: vec![],
      strict: true,
    },
  }];
  let sql = generate_sql_for(&ops, Dialect::Sqlite);
  assert!(sql.contains("REFERENCES \"conversations\"(\"id\")"));
}

#[test]
fn test_create_table_with_on_delete_cascade() {
  let ops = vec![Operation::CreateTable {
    table: TableDef {
      name: "nodes".to_owned(),
      columns: vec![ColumnDef {
        name: "pipeline_id".to_owned(),
        column_type: ColumnType::Uuid,
        primary_key: false,
        not_null: true,
        default: None,
        unique: false,
        references: Some("pipelines(id)".to_owned()),
        on_delete: Some(ForeignKeyAction::Cascade),
        on_update: None,
        check: None,
      }],
      indexes: vec![],
      strict: true,
    },
  }];
  let sql = generate_sql_for(&ops, Dialect::Sqlite);
  assert!(
    sql.contains("ON DELETE CASCADE"),
    "expected ON DELETE CASCADE, got: {sql}"
  );
  assert!(
    sql.contains(r#"REFERENCES "pipelines"("id")"#),
    "expected REFERENCES, got: {sql}"
  );
}

#[test]
fn test_create_table_with_check_constraint() {
  let ops = vec![Operation::CreateTable {
    table: TableDef {
      name: "pipelines".to_owned(),
      columns: vec![ColumnDef {
        name: "status".to_owned(),
        column_type: ColumnType::Text,
        primary_key: false,
        not_null: true,
        default: Some("'draft'".to_owned()),
        unique: false,
        references: None,
        on_delete: None,
        on_update: None,
        check: Some(r#"CHECK("status" IN ('draft', 'active', 'archived'))"#.to_owned()),
      }],
      indexes: vec![],
      strict: true,
    },
  }];
  let sql = generate_sql_for(&ops, Dialect::Sqlite);
  assert!(
    sql.contains(r#"CHECK("status" IN ('draft', 'active', 'archived'))"#),
    "got: {sql}"
  );
}