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

//! Trigger teardown statements.

use super::super::trigger::{drop_marker, function_name, Direction, Trigger};
use super::super::Plan;

impl Plan {
    /// Drops every trigger and function this plan installed.
    pub(super) fn remove_triggers(&self) -> Vec<String> {
        let mut statements = Vec::new();
        for table in self.touched_tables() {
            for column in self.trigger_columns(&table) {
                statements.extend(
                    Trigger {
                        table: &table,
                        physical_column: &column,
                        direction: Direction::Up,
                        expression: "NULL",
                        latest_schema: "",
                        rewrite: None,
                    }
                    .remove(),
                );
            }
        }
        statements
    }

    /// Removes the backfill marker column from every touched table.
    pub(super) fn drop_markers(&self) -> Vec<String> {
        self.touched_tables()
            .iter()
            .map(|table| drop_marker(table))
            .collect()
    }

    /// Returns every table this plan installed a trigger on.
    pub(super) fn touched_tables(&self) -> Vec<String> {
        let mut tables = self.backfill_tables.clone();
        tables.sort();
        tables.dedup();
        tables
    }

    /// Returns the physical columns carrying triggers on `table`.
    ///
    /// Derived from the generated statements rather than tracked separately, so the
    /// two cannot drift out of sync.
    fn trigger_columns(&self, table: &str) -> Vec<String> {
        let prefix = function_name(table, "");
        let mut columns: Vec<String> = self
            .statements
            .iter()
            .filter_map(|statement| statement.split(&prefix).nth(1))
            .filter_map(|rest| rest.split('"').next())
            .filter(|column| !column.is_empty())
            .map(str::to_string)
            .collect();
        columns.sort();
        columns.dedup();
        columns
    }
}