hamelin_lib 0.21.8

Core library for Hamelin query language
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

use crate::sql::expression::identifier::SimpleIdentifier;
use crate::sql::query::cte::CTE;
use crate::sql::query::{SQLQuery, SQLQueryExpression};
use crate::write_utils::{blank_line_or_space, maybe_pad, Indent};
use std::fmt;
use std::fmt::{Display, Formatter};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Type {
    Union,
    UnionAll,
    UnionDistinct,
    Intersect,
    IntersectAll,
    IntersectDistinct,
    Except,
    ExceptAll,
    ExceptDistinct,
}

impl Type {
    pub fn fmt_indented(&self, f: &mut Formatter<'_>, _indentation: Indent) -> fmt::Result {
        match self {
            Type::Union => write!(f, "UNION"),
            Type::UnionAll => write!(f, "UNION ALL"),
            Type::UnionDistinct => write!(f, "UNION DISTINCT"),
            Type::Intersect => write!(f, "INTERSECT"),
            Type::IntersectAll => write!(f, "INTERSECT ALL"),
            Type::IntersectDistinct => write!(f, "INTERSECT DISTINCT"),
            Type::Except => write!(f, "EXCEPT"),
            Type::ExceptAll => write!(f, "EXCEPT ALL"),
            Type::ExceptDistinct => write!(f, "EXCEPT DISTINCT"),
        }
    }
}

impl Display for Type {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        self.fmt_indented(f, Indent::default())
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SetOperation {
    pub typ: Type,
    pub left: Box<SQLQueryExpression>,
    pub right: Box<SQLQueryExpression>,
    pub cte: CTE,
}

impl SetOperation {
    pub fn new(left: SQLQueryExpression, right: SQLQueryExpression) -> Self {
        Self {
            typ: Type::UnionAll,
            left: Box::new(left),
            right: Box::new(right),
            cte: CTE::default(),
        }
    }

    pub fn with_cte(mut self, name: SimpleIdentifier, query: SQLQuery) -> Self {
        self.cte = self.cte.with(name, query);
        self
    }

    pub fn fmt_indented(&self, f: &mut Formatter<'_>, indentation: Indent) -> fmt::Result {
        self.cte.fmt_indented(f, indentation)?;

        maybe_pad(f, indentation)?;
        self.left.fmt_indented(f, indentation)?;
        blank_line_or_space(f, indentation)?;
        maybe_pad(f, indentation)?;
        self.typ.fmt_indented(f, indentation)?;
        blank_line_or_space(f, indentation)?;
        maybe_pad(f, indentation)?;
        self.right.fmt_indented(f, indentation)
    }
}