saola-quaint 0.2.0-alpha.14

An abstraction layer for SQL databases (PostgreSQL, MySQL, SQLite, MSSQL)
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

use std::borrow::Cow;

use super::ColumnType;

#[derive(Debug)]
pub struct DescribedQuery {
    pub parameters: Vec<DescribedParameter>,
    pub columns: Vec<DescribedColumn>,
    pub enum_names: Option<Vec<String>>,
}

impl DescribedQuery {
    pub fn param_enum_names(&self) -> Vec<&str> {
        self.parameters.iter().filter_map(|p| p.enum_name.as_deref()).collect()
    }
}

#[derive(Debug)]
pub struct DescribedParameter {
    pub name: String,
    pub typ: ColumnType,
    pub enum_name: Option<String>,
}

#[derive(Debug)]
pub struct DescribedColumn {
    pub name: String,
    pub typ: ColumnType,
    pub nullable: bool,
    pub enum_name: Option<String>,
}

impl DescribedParameter {
    pub fn new_named<'a>(name: impl Into<Cow<'a, str>>, typ: impl Into<ColumnType>) -> Self {
        let name: Cow<'_, str> = name.into();

        Self {
            name: name.into_owned(),
            typ: typ.into(),
            enum_name: None,
        }
    }

    pub fn new_unnamed(idx: usize, typ: impl Into<ColumnType>) -> Self {
        Self {
            name: format!("_{idx}"),
            typ: typ.into(),
            enum_name: None,
        }
    }

    pub fn with_enum_name(mut self, enum_name: Option<String>) -> Self {
        self.enum_name = enum_name;
        self
    }

    pub fn set_typ(mut self, typ: ColumnType) -> Self {
        self.typ = typ;
        self
    }
}

impl DescribedColumn {
    pub fn new_named<'a>(name: impl Into<Cow<'a, str>>, typ: impl Into<ColumnType>) -> Self {
        let name: Cow<'_, str> = name.into();

        Self {
            name: name.into_owned(),
            typ: typ.into(),
            enum_name: None,
            nullable: false,
        }
    }

    pub fn new_unnamed(idx: usize, typ: impl Into<ColumnType>) -> Self {
        Self {
            name: format!("_{idx}"),
            typ: typ.into(),
            enum_name: None,
            nullable: false,
        }
    }

    pub fn with_enum_name(mut self, enum_name: Option<String>) -> Self {
        self.enum_name = enum_name;
        self
    }

    pub fn is_nullable(mut self, nullable: bool) -> Self {
        self.nullable = nullable;
        self
    }
}