ensemble 0.0.5

A Laravel-inspired 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
128
129

use std::{fmt::Display, sync::mpsc};

use ensemble_derive::Column;

use crate::connection::{self, Database};

use super::Schemable;

#[derive(Debug)]
pub struct Command {
	pub(crate) inline_sql: String,
	pub(crate) post_sql: Option<String>,
}

/// A foreign key constraint.
#[derive(Debug, Clone, Column)]
#[allow(dead_code)]
pub struct ForeignIndex {
	#[builder(init)]
	column: String,
	#[builder(init)]
	origin_table: String,
	/// The name of the foreign index.
	name: Option<String>,
	/// The name of the column in the foreign table.
	#[builder(rename = "references")]
	foreign_column: Option<String>,
	/// The name of the foreign table.
	#[builder(rename = "on")]
	table: String,
	/// The action to take when the foreign row is deleted.
	#[builder(into)]
	on_delete: Option<OnAction>,
	/// The action to take when the foreign row is updated.
	#[builder(into)]
	on_update: Option<OnAction>,

	#[builder(init)]
	tx: Option<mpsc::Sender<Schemable>>,
}

impl ForeignIndex {
	fn to_sql(&self) -> (String, Option<String>) {
		let foreign_column = &self
			.foreign_column
			.as_ref()
			.expect("failed to build index: foreign column must be specified");

		let index_name = self.name.as_ref().map_or_else(
			|| format!("{}_{}_foreign", self.origin_table, self.column),
			ToString::to_string,
		);

		let mut sql = match connection::which_db() {
            Database::MySQL => format!(
                "KEY {index_name} ({}), CONSTRAINT {index_name} FOREIGN KEY ({}) REFERENCES {}({foreign_column})", self.column, self.column, self.table,
            ),
            Database::PostgreSQL => format!(
                "FOREIGN KEY ({}) REFERENCES {}({foreign_column})",
                self.column, self.table,
            )
        };

		if let Some(on_delete) = &self.on_delete {
			sql.push_str(&format!(" ON DELETE {on_delete}"));
		}

		if let Some(on_update) = &self.on_update {
			sql.push_str(&format!(" ON UPDATE {on_update}"));
		}

		match connection::which_db() {
			Database::MySQL => (sql, None),
			Database::PostgreSQL => (
				sql,
				Some(format!(
					"CREATE INDEX {index_name} ON {}({});",
					self.origin_table, self.column
				)),
			),
		}
	}
}

// Incredibly cursed impl that basically recreates PHP's `__destruct` magic method.
// If you're mad about this, go use sqlx or something idk.
impl Drop for ForeignIndex {
	fn drop(&mut self) {
		if let Some(tx) = self.tx.take() {
			let (inline_sql, post_sql) = self.to_sql();

			tx.send(Schemable::Command(Command {
				inline_sql,
				post_sql,
			}))
			.unwrap();
			drop(tx);
		}
	}
}

#[derive(Debug, Clone, Copy)]
pub enum OnAction {
	Restrict,
	Cascade,
	SetNull,
}

impl Display for OnAction {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match self {
			Self::Cascade => write!(f, "CASCADE"),
			Self::SetNull => write!(f, "SET NULL"),
			Self::Restrict => write!(f, "RESTRICT"),
		}
	}
}

#[allow(clippy::fallible_impl_from)]
impl From<&str> for OnAction {
	fn from(s: &str) -> Self {
		match s.to_uppercase().as_str() {
			"CASCADE" => Self::Cascade,
			"SET NULL" => Self::SetNull,
			"RESTRICT" => Self::Restrict,
			_ => panic!("invalid action"),
		}
	}
}