rustyroad 1.8.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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

//! Declarative operations: safe column changes via shadow columns and backfill.
//!
//! A raw-SQL migration that renames or retypes a column breaks readers of the old
//! schema the moment it runs. A declared operation instead:
//!
//! 1. creates a shadow physical column beside the original,
//! 2. installs triggers so a write through either schema version populates both,
//! 3. backfills existing rows in batches, and
//! 4. at completion, promotes the shadow and drops the original.
//!
//! Both versions therefore read and write correctly for the whole rollout.

pub mod backfill;
pub mod duplicate;
pub mod model;
mod plan_complete;
mod plan_start;
pub mod trigger;

use super::quote::quote_ident;
use model::Migration;

/// Statements and follow-up work for one migration's operations.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Plan {
    /// Statements applied during `start`.
    pub statements: Vec<String>,
    /// Tables needing a batched backfill after `start`.
    pub backfill_tables: Vec<String>,
    /// Shadow columns to promote at completion: `(table, column)`.
    pub promotions: Vec<(String, String)>,
    /// Columns to drop at completion: `(table, column)`.
    pub drops: Vec<(String, String)>,
    /// Columns to rename at completion: `(table, from, to)`.
    pub renames: Vec<(String, String, String)>,
    /// NOT NULL constraints deferred until the backfill finished.
    pub deferred_not_null: Vec<(String, String)>,
}

/// Builds the plan for every operation in `migration`.
pub fn plan(migration: &Migration, latest_schema: &str) -> Plan {
    let mut combined = Plan::default();

    for operation in &migration.operations {
        let plan = plan_start::plan(operation, latest_schema);
        combined.statements.extend(plan.statements);
        combined.backfill_tables.extend(plan.backfill_tables);
        combined.promotions.extend(plan.promotions);
        combined.drops.extend(plan.drops);
        combined.renames.extend(plan.renames);
        combined.deferred_not_null.extend(plan.deferred_not_null);
    }

    combined.backfill_tables.sort();
    combined.backfill_tables.dedup();
    combined
}

/// Returns a `NEW.<column>` reference, the default forward expression.
fn new_ref(column: &str) -> String {
    format!("NEW.{}", quote_ident(column))
}