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
116
117
118
119
120
121
122
123
124
125
126
127

use toolu_orm_core::column::{ColumnDef, ColumnType};
use toolu_orm_core::diff::{ColumnChange, Operation};
use toolu_orm_core::ordering::order_operations;
use toolu_orm_core::table::TableDef;

#[test]
fn full_ordering_13_tiers() {
  let ops = vec![
    Operation::DropEnum {
      name: "old_enum".to_owned(),
    },
    Operation::DropTable {
      name: "old_table".to_owned(),
    },
    Operation::DropColumn {
      table: "t".to_owned(),
      column: "c".to_owned(),
    },
    Operation::AddCheckConstraint {
      table: "t".to_owned(),
      name: "chk".to_owned(),
      expr: "expr".to_owned(),
    },
    Operation::AddColumn {
      table: "t".to_owned(),
      column: ColumnDef {
        name: "new_col".to_owned(),
        column_type: ColumnType::Text,
        primary_key: false,
        not_null: false,
        default: None,
        unique: false,
        references: None,
        on_delete: None,
        on_update: None,
        check: None,
      },
    },
    Operation::AlterColumn {
      table: "t".to_owned(),
      changes: vec![ColumnChange::Nullable {
        column: "x".to_owned(),
        old: true,
        new: false,
      }],
      table_def: TableDef {
        name: "t".to_owned(),
        columns: vec![],
        indexes: vec![],
        strict: false,
      },
    },
    Operation::DropCheckConstraint {
      table: "t".to_owned(),
      name: "old_chk".to_owned(),
    },
    Operation::RenameColumn {
      table: "t".to_owned(),
      old: "a".to_owned(),
      new: "b".to_owned(),
    },
    Operation::RenameTable {
      old: "x".to_owned(),
      new: "y".to_owned(),
    },
    Operation::CreateTable {
      table: TableDef {
        name: "new_table".to_owned(),
        columns: vec![],
        indexes: vec![],
        strict: false,
      },
    },
    Operation::AlterEnum {
      name: "e".to_owned(),
      added: vec!["v".to_owned()],
      removed: vec![],
    },
    Operation::CreateEnum {
      name: "new_enum".to_owned(),
      variants: vec!["a".to_owned()],
    },
    Operation::AlterEnum {
      name: "e2".to_owned(),
      added: vec![],
      removed: vec!["old_v".to_owned()],
    },
  ];

  let ordered = order_operations(ops);

  let tier = |op: &Operation| -> u8 {
    match op {
      Operation::CreateEnum { .. } => 1,
      Operation::AlterEnum { removed, .. } if removed.is_empty() => 2,
      Operation::CreateTable { .. } => 3,
      Operation::RenameTable { .. } => 4,
      Operation::RenameColumn { .. } => 5,
      Operation::DropForeignKey { .. }
      | Operation::DropIndex { .. }
      | Operation::DropCheckConstraint { .. } => 6,
      Operation::AlterColumn { .. } => 7,
      Operation::AddColumn { .. } => 8,
      Operation::AddForeignKey { .. }
      | Operation::CreateIndex { .. }
      | Operation::AddCheckConstraint { .. } => 9,
      Operation::DropColumn { .. } => 10,
      Operation::DropTable { .. } => 11,
      Operation::DropEnum { .. } => 12,
      Operation::AlterEnum { .. } => 13,
    }
  };

  for window in ordered.windows(2) {
    match window {
      [a, b] => assert!(
        tier(a) <= tier(b),
        "ordering violation: {:?} (tier {}) came before {:?} (tier {})",
        a,
        tier(a),
        b,
        tier(b)
      ),
      _ => assert_eq!(window.len(), 2, "windows(2) must yield length-2 slices"),
    }
  }
}