modql 0.4.1

Rust implementation for Model Query Language support
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

use crate::field::SeaField;
use sea_query::{DynIden, SimpleExpr};

#[derive(Debug, Clone)]
pub struct SeaFields(Vec<SeaField>);

// Constructor
impl SeaFields {
	pub fn new(fields: Vec<SeaField>) -> Self {
		SeaFields(fields)
	}
}

// Api
impl SeaFields {
	/// Simple api to append a SeaField to the list.
	pub fn push(&mut self, field: SeaField) {
		self.0.push(field);
	}

	/// The consuming builder API equivalent to `push(..)`
	pub fn append(mut self, field: SeaField) -> Self {
		self.push(field);
		self
	}

	/// The static 'str for iden version of the `append(..)`
	pub fn append_siden(mut self, iden: &'static str, value: impl Into<SimpleExpr>) -> Self {
		let field = SeaField::siden(iden, value);
		self.push(field);
		self
	}

	pub fn into_vec(self) -> Vec<SeaField> {
		self.0
	}

	/// Alias to self.unzip()
	pub fn for_sea_insert(self) -> (Vec<DynIden>, Vec<SimpleExpr>) {
		self.unzip()
	}

	/// returns a tuble: (Vec_of_column_idens, Vec_of_value_exprs)
	pub fn unzip(self) -> (Vec<DynIden>, Vec<SimpleExpr>) {
		self.0.into_iter().map(|f| (f.iden, f.value)).unzip()
	}

	/// Alias to self.zip()
	pub fn for_sea_update(self) -> impl Iterator<Item = (DynIden, SimpleExpr)> {
		self.zip()
	}

	/// returns Iterator of (column_iden, value_expr)
	/// Useful for sea query update.
	pub fn zip(self) -> impl Iterator<Item = (DynIden, SimpleExpr)> {
		self.0.into_iter().map(|f| (f.iden, f.value))
	}
}

impl IntoIterator for SeaFields {
	type Item = SeaField;
	type IntoIter = std::vec::IntoIter<Self::Item>;

	fn into_iter(self) -> Self::IntoIter {
		self.0.into_iter()
	}
}

// region:    --- Froms

impl From<Vec<SeaField>> for SeaFields {
	fn from(val: Vec<SeaField>) -> Self {
		SeaFields(val)
	}
}

impl From<SeaField> for SeaFields {
	fn from(val: SeaField) -> Self {
		SeaFields(vec![val])
	}
}

// endregion: --- Froms