-
Notifications
You must be signed in to change notification settings - Fork 217
/
column.rs
108 lines (91 loc) 路 2.63 KB
/
column.rs
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
use crate::model_extensions::ScalarFieldExt;
use itertools::Itertools;
use prisma_models::{Field, ModelProjection, RelationField, ScalarField};
use quaint::ast::{Column, Row};
use std::convert::AsRef;
pub struct ColumnIterator {
inner: Box<dyn Iterator<Item = Column<'static>> + 'static>,
}
impl Iterator for ColumnIterator {
type Item = Column<'static>;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
}
impl From<Vec<Column<'static>>> for ColumnIterator {
fn from(v: Vec<Column<'static>>) -> Self {
Self {
inner: Box::new(v.into_iter()),
}
}
}
pub trait AsRow {
fn as_row(&self) -> Row<'static>;
}
pub trait AsColumns {
fn as_columns(&self) -> ColumnIterator;
}
impl AsColumns for ModelProjection {
fn as_columns(&self) -> ColumnIterator {
let cols: Vec<Column<'static>> = self
.fields()
.flat_map(|f| f.as_columns())
.unique_by(|c| c.name.clone())
.collect();
ColumnIterator::from(cols)
}
}
impl AsRow for ModelProjection {
fn as_row(&self) -> Row<'static> {
let cols: Vec<Column<'static>> = self.as_columns().collect();
Row::from(cols)
}
}
pub trait AsColumn {
fn as_column(&self) -> Column<'static>;
}
impl AsColumns for Field {
fn as_columns(&self) -> ColumnIterator {
match self {
Field::Scalar(ref sf) => ColumnIterator::from(vec![sf.as_column()]),
Field::Relation(ref rf) => rf.as_columns(),
Field::Composite(_) => unimplemented!(),
}
}
}
impl AsColumns for RelationField {
fn as_columns(&self) -> ColumnIterator {
self.scalar_fields().as_columns()
}
}
impl<T> AsColumns for &[T]
where
T: AsColumn,
{
fn as_columns(&self) -> ColumnIterator {
let inner: Vec<_> = self.iter().map(|x| x.as_column()).collect();
ColumnIterator::from(inner)
}
}
impl<T> AsColumns for Vec<T>
where
T: AsColumn,
{
fn as_columns(&self) -> ColumnIterator {
let inner: Vec<_> = self.iter().map(|x| x.as_column()).collect();
ColumnIterator::from(inner)
}
}
impl<T> AsColumn for T
where
T: AsRef<ScalarField>,
{
fn as_column(&self) -> Column<'static> {
let sf = self.as_ref();
// Unwrap is safe: SQL connectors do not anything other than models as field containers.
let full_table_name = sf.container.as_model().unwrap().db_name_with_schema();
let col = sf.db_name().to_string();
let column = Column::from((full_table_name, col)).type_family(sf.type_family());
column.default(quaint::ast::DefaultValue::Generated)
}
}