hamelin_lib 0.23.2

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
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
109
110
111
112

//! Identifier builder for constructing simple and compound identifiers
//!
//! This module provides a fluent API for building identifiers with dots.

use crate::tree::ast::identifier::{CompoundIdentifier, Identifier, SimpleIdentifier};

/// Builder for identifiers
#[derive(Debug)]
pub struct IdentifierBuilder {
    parts: Vec<SimpleIdentifier>,
}

impl IdentifierBuilder {
    pub fn new(name: impl Into<String>) -> Self {
        Self {
            parts: vec![SimpleIdentifier::new(name)],
        }
    }

    /// Add another part to create a compound identifier
    /// Example: `ident("schema").dot("table").dot("column")`
    pub fn dot(mut self, name: impl Into<String>) -> Self {
        self.parts.push(SimpleIdentifier::new(name));
        self
    }

    pub fn build(&self) -> Identifier {
        match self.parts.as_slice() {
            [] => unreachable!("IdentifierBuilder always has at least one part"),
            [single] => single.clone().into(),
            [first, second, rest @ ..] => {
                CompoundIdentifier::new(first.clone(), second.clone(), rest.to_vec()).into()
            }
        }
    }
}

// Allow IdentifierBuilder to be converted into Identifier
impl From<IdentifierBuilder> for Identifier {
    fn from(builder: IdentifierBuilder) -> Self {
        builder.build()
    }
}

/// Create an identifier builder
pub fn ident(name: impl Into<String>) -> IdentifierBuilder {
    IdentifierBuilder::new(name)
}

// Convenience conversions for builder API
impl From<String> for Identifier {
    fn from(name: String) -> Self {
        SimpleIdentifier::new(name).into()
    }
}

impl From<&str> for Identifier {
    fn from(name: &str) -> Self {
        SimpleIdentifier::new(name).into()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn test_simple_identifier() {
        let id = ident("column").build();
        match id {
            Identifier::Simple(s) => assert!(s == "column"),
            _ => panic!("Expected simple identifier"),
        }
    }

    #[test]
    fn test_compound_identifier_two_parts() {
        let id = ident("table").dot("column").build();
        match id {
            Identifier::Compound(c) => {
                assert_eq!(c.parts().len(), 2);
                assert!(c.parts()[0] == "table");
                assert!(c.parts()[1] == "column");
            }
            _ => panic!("Expected compound identifier"),
        }
    }

    #[test]
    fn test_compound_identifier_three_parts() {
        let id = ident("schema").dot("table").dot("column").build();
        match id {
            Identifier::Compound(c) => {
                assert_eq!(c.parts().len(), 3);
                assert!(c.parts()[0] == "schema");
                assert!(c.parts()[1] == "table");
                assert!(c.parts()[2] == "column");
            }
            _ => panic!("Expected compound identifier"),
        }
    }

    #[test]
    fn test_identifier_from_string() {
        let id: Identifier = "column".into();
        match id {
            Identifier::Simple(s) => assert!(s == "column"),
            _ => panic!("Expected simple identifier"),
        }
    }
}