glaredb_parser 25.6.3

SQL parser for GlareDB
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

use glaredb_error::Result;
use serde::{Deserialize, Serialize};

use super::{AstParseable, Expr};
use crate::keywords::Keyword;
use crate::meta::{AstMeta, Raw};
use crate::parser::Parser;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OrderByModifier<T: AstMeta> {
    pub order_by_nodes: Vec<OrderByNode<T>>,
}

/// A single node in an ORDER BY clause.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OrderByNode<T: AstMeta> {
    pub typ: Option<OrderByType>,
    pub nulls: Option<OrderByNulls>,
    pub expr: Expr<T>,
}

impl AstParseable for OrderByNode<Raw> {
    fn parse(parser: &mut Parser) -> Result<Self> {
        let expr = Expr::parse(parser)?;

        let typ = if parser.parse_keyword(Keyword::ASC) {
            Some(OrderByType::Asc)
        } else if parser.parse_keyword(Keyword::DESC) {
            Some(OrderByType::Desc)
        } else {
            None
        };

        let nulls = if parser.parse_keyword_sequence(&[Keyword::NULLS, Keyword::FIRST]) {
            Some(OrderByNulls::First)
        } else if parser.parse_keyword_sequence(&[Keyword::NULLS, Keyword::LAST]) {
            Some(OrderByNulls::Last)
        } else {
            None
        };

        Ok(OrderByNode { typ, nulls, expr })
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum OrderByType {
    Asc,
    Desc,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum OrderByNulls {
    First,
    Last,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LimitModifier<T: AstMeta> {
    pub limit: Option<Expr<T>>,
    pub offset: Option<Expr<T>>,
}

impl AstParseable for LimitModifier<Raw> {
    fn parse(parser: &mut Parser) -> Result<Self> {
        let mut limit = None;
        let mut offset = None;

        if parser.parse_keyword(Keyword::LIMIT) {
            limit = Some(Expr::parse(parser)?)
        }

        if parser.parse_keyword(Keyword::OFFSET) {
            offset = Some(Expr::parse(parser)?)
        }

        // Try limit again since LIMIT and OFFSET can be specified in any order.
        if parser.parse_keyword(Keyword::LIMIT) {
            limit = Some(Expr::parse(parser)?)
        }

        Ok(LimitModifier { limit, offset })
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum DistinctModifier<T: AstMeta> {
    /// DISTINCT
    Distinct,
    /// DISTINCT ON
    On(Vec<Expr<T>>),
    /// ALL
    All,
}