osirisdb 0.7.0

A SQL database engine built from scratch in Rust featuring a custom parser, binder, query planner, optimizer, catalog, and storage engine.
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

use crate::{
    ast::{CreateViewStmt, ObjectName, ViewCheckOption},
    lexer::TokenKind,
    parser::{parser::Parser, parser_error::ParserError},
};

impl<'a> Parser<'a> {
    /// Executes parsing or lookup for the `parse_create_view` operation.
    pub fn parse_create_view(
        &mut self,
        or_replace: bool,
        temporary: bool,
        recursive: bool,
    ) -> Result<CreateViewStmt, ParserError> {
        let name = ObjectName(self.parse_qualified_name()?);
        let columns = if self.consume(&TokenKind::LParen) {
            let mut cols = vec![];

            loop {
                cols.push(self.expect_identifier()?);
                if !self.consume(&TokenKind::Comma) {
                    break;
                }
            }
            self.expect(TokenKind::RParen)?;
            cols
        } else {
            vec![]
        };

        let with_options = if self.consume(&TokenKind::With) {
            self.parse_options_list()?
        } else {
            vec![]
        };

        self.expect(TokenKind::As)?;

        let query = Box::new(self.parse_select()?);

        let check_option = if self.consume(&TokenKind::With) {
            if matches!(self.current_token(), TokenKind::Ident) {
                let word =
                    self.source[self.current.span.start..self.current.span.end].to_uppercase();

                match word.as_str() {
                    "LOCAL" => {
                        self.advance();
                        self.expect_keyword_sequence(&[TokenKind::Check, TokenKind::Options])?;
                        Some(ViewCheckOption::Local)
                    }
                    "CASCADE" => {
                        self.advance();
                        self.expect_keyword_sequence(&[TokenKind::Check, TokenKind::Options])?;
                        Some(ViewCheckOption::Cascaded)
                    }
                    _ => {
                        self.expect_keyword_sequence(&[TokenKind::Check, TokenKind::Options])?;
                        Some(ViewCheckOption::Cascaded) // default
                    }
                }
            } else {
                self.expect_keyword_sequence(&[TokenKind::Check, TokenKind::Options])?;
                Some(ViewCheckOption::Cascaded)
            }
        } else {
            None
        };

        Ok(CreateViewStmt {
            or_replace,
            temporary,
            recursive,
            name,
            columns,
            with_options,
            query,
            check_option,
        })
    }
}