vantage-sql 0.5.6

Vantage extension for SQL databases (Postgres, MySQL, SQLite)
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

use std::fmt::{Debug, Display};
use vantage_expressions::{Expression, Expressive, ExpressiveEnum};

/// Cross-database GROUP_CONCAT / STRING_AGG / array_agg aggregation.
///
/// Aggregates values from multiple rows into a single string.
#[derive(Debug, Clone)]
pub struct GroupConcat<T: Debug + Display + Clone> {
    expr: Expression<T>,
    separator: String,
    distinct: bool,
}

impl<T: Debug + Display + Clone> GroupConcat<T> {
    pub fn new(expr: impl Expressive<T>) -> Self {
        Self {
            expr: expr.expr(),
            separator: ",".to_string(),
            distinct: false,
        }
    }

    pub fn separator(mut self, sep: impl Into<String>) -> Self {
        self.separator = sep.into();
        self
    }

    pub fn distinct(mut self) -> Self {
        self.distinct = true;
        self
    }
}

// SQLite: GROUP_CONCAT(DISTINCT expr, separator)
#[cfg(feature = "sqlite")]
impl Expressive<crate::sqlite::types::AnySqliteType>
    for GroupConcat<crate::sqlite::types::AnySqliteType>
{
    fn expr(&self) -> Expression<crate::sqlite::types::AnySqliteType> {
        let distinct_kw = if self.distinct { "DISTINCT " } else { "" };
        let template = format!("GROUP_CONCAT({}{{}}, '{}')", distinct_kw, self.separator);
        Expression::new(&template, vec![ExpressiveEnum::Nested(self.expr.clone())])
    }
}

// PostgreSQL: STRING_AGG(DISTINCT expr, separator)
#[cfg(feature = "postgres")]
impl Expressive<crate::postgres::types::AnyPostgresType>
    for GroupConcat<crate::postgres::types::AnyPostgresType>
{
    fn expr(&self) -> Expression<crate::postgres::types::AnyPostgresType> {
        let distinct_kw = if self.distinct { "DISTINCT " } else { "" };
        let template = format!("STRING_AGG({}{{}}, '{}')", distinct_kw, self.separator);
        Expression::new(&template, vec![ExpressiveEnum::Nested(self.expr.clone())])
    }
}

// MySQL: GROUP_CONCAT(DISTINCT expr SEPARATOR separator)
#[cfg(feature = "mysql")]
impl Expressive<crate::mysql::types::AnyMysqlType>
    for GroupConcat<crate::mysql::types::AnyMysqlType>
{
    fn expr(&self) -> Expression<crate::mysql::types::AnyMysqlType> {
        let distinct_kw = if self.distinct { "DISTINCT " } else { "" };
        let template = format!(
            "GROUP_CONCAT({}{{}} SEPARATOR '{}')",
            distinct_kw, self.separator
        );
        Expression::new(&template, vec![ExpressiveEnum::Nested(self.expr.clone())])
    }
}