rustyroad 1.7.0

Rusty Road is a framework written in Rust that is based on Ruby on Rails. It is designed to provide the familiar conventions and ease of use of Ruby on Rails, while also taking advantage of the performance and efficiency of Rust.
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

//! Planning the start phase of a declarative operation.

mod add;
mod alter;

use super::model::{DropColumn, Operation};
use super::trigger::{Direction, Trigger};
use super::Plan;

/// Builds the start-phase plan for `operation`.
pub(super) fn plan(operation: &Operation, latest_schema: &str) -> Plan {
    match operation {
        Operation::AddColumn(op) => add::plan(op, latest_schema),
        Operation::AlterColumn(op) => alter::plan(op, latest_schema),
        Operation::DropColumn(op) => drop_column(op, latest_schema),
        Operation::Sql(op) => Plan {
            statements: vec![op.up.clone()],
            ..Plan::default()
        },
    }
}

/// Drops a column at completion, keeping it populated until then.
fn drop_column(op: &DropColumn, latest_schema: &str) -> Plan {
    let mut plan = Plan {
        drops: vec![(op.table.clone(), op.column.clone())],
        ..Plan::default()
    };

    // Old readers still select this column, so new writes must keep filling it.
    if let Some(down) = &op.down {
        plan.statements.extend(
            Trigger {
                table: &op.table,
                physical_column: &op.column,
                direction: Direction::Down,
                expression: down,
                latest_schema,
                rewrite: None,
            }
            .install(),
        );
        plan.backfill_tables.push(op.table.clone());
    }

    plan
}