orql 0.1.0

A toy SQL parser for a subset of the Oracle dialect.
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

use super::{MetaTracker, ParserInner, Result};
use crate::{
    ast::{ForUpdate, ForUpdateLockOptions, ForUpdateOfColumns, Node},
    parser::parse_comma_separated,
    scanner::{Keyword, Reserved, Token, TokenType},
};

impl<'s, M> ParserInner<'s, M>
where
    M: MetaTracker<'s>,
{
    pub(super) fn parse_for_update(&mut self) -> Result<Option<ForUpdate<'s, M::NodeId>>> {
        if let Some(Token {
            ttype: TokenType::Keyword(Keyword::FOR),
            loc,
        }) = self.peek_token()?
        {
            let for_token = {
                let loc = *loc;
                self.consume_token()?;
                Node((), self.meta_tracker.on_node_start(loc))
            };
            let update_token = expect_token!(|t = self.next_token()| "the UPDATE keyword" match {
                TokenType::Keyword(Keyword::UPDATE) => Node((), self.meta_tracker.on_node_start(t.loc)),
            });
            let of_columns = if let Some(Token {
                ttype: TokenType::Keyword(Keyword::OF),
                loc,
            }) = self.peek_token()?
            {
                let of_token = {
                    let loc = *loc;
                    self.consume_token()?;
                    Node((), self.meta_tracker.on_node_start(loc))
                };
                let columns = parse_comma_separated(self, |parser| parser.parse_identifier())?;
                Some(ForUpdateOfColumns { of_token, columns })
            } else {
                None
            };
            let lock_opts = if let Some(t) = self.peek_token()? {
                match t.ttype {
                    TokenType::Keyword(Keyword::NOWAIT) => {
                        let loc = t.loc;
                        self.consume_token()?;
                        let nowait_token = Node((), self.meta_tracker.on_node_start(loc));
                        Some(ForUpdateLockOptions::NoWait { nowait_token })
                    }
                    // XXX
                    TokenType::Identifier(_, Some(reserved)) => match reserved {
                        Reserved::WAIT => {
                            let wait_token = {
                                let loc = t.loc;
                                self.consume_token()?;
                                Node((), self.meta_tracker.on_node_start(loc))
                            };
                            let duration = self.parse_integer_node()?;
                            Some(ForUpdateLockOptions::Wait {
                                wait_token,
                                duration,
                            })
                        }
                        Reserved::SKIP => {
                            let skip_token = {
                                let loc = t.loc;
                                self.consume_token()?;
                                Node((), self.meta_tracker.on_node_start(loc))
                            };
                            let locked_token = expect_reserved!(|t = self.next_token()| "the LOCKED keyword" match {
                                Reserved::LOCKED => Node((), self.meta_tracker.on_node_start(t.loc)),
                            });
                            Some(ForUpdateLockOptions::Skip {
                                skip_token,
                                locked_token,
                            })
                        }
                        _ => None,
                    },
                    _ => None,
                }
            } else {
                None
            };
            Ok(Some(ForUpdate {
                for_token,
                update_token,
                of_columns,
                lock_opts,
            }))
        } else {
            Ok(None)
        }
    }

    fn parse_integer_node(&mut self) -> Result<Node<&'s str, M::NodeId>> {
        expect_token!(|t = self.next_token()| "an integer" match {
            TokenType::Integer(s) => Ok(Node(s, self.meta_tracker.on_node_start(t.loc))),
        })
    }
}