nodedb-sql 0.2.0

SQL parser, planner, and optimizer for NodeDB
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// SPDX-License-Identifier: Apache-2.0

//! `CLONE DATABASE <new> FROM <source> [AS OF SYSTEM TIME <ms> | LATEST]`.

use crate::ddl_ast::statement::{CloneAsOf, NodedbStatement};
use crate::error::SqlError;

pub(super) fn parse_clone_database(
    parts: &[&str],
    upper: &str,
) -> Result<NodedbStatement, SqlError> {
    let new_name = parts
        .get(2)
        .copied()
        .ok_or_else(|| SqlError::Parse {
            detail: "CLONE DATABASE requires a target name".into(),
        })?
        .trim_matches('"')
        .to_string();
    let from_idx = parts
        .iter()
        .position(|w| w.to_uppercase() == "FROM")
        .ok_or_else(|| SqlError::Parse {
            detail: "CLONE DATABASE requires FROM <source>".into(),
        })?;
    let source_name = parts
        .get(from_idx + 1)
        .copied()
        .ok_or_else(|| SqlError::Parse {
            detail: "CLONE DATABASE FROM requires a source name".into(),
        })?
        .trim_matches('"')
        .to_string();

    // Determine the AS OF clause.
    // Accepted forms:
    //   (no AS OF)                            → Latest
    //   AS OF SYSTEM TIME LATEST              → Latest
    //   AS OF SYSTEM TIME <ms>                → SystemTimeMs(<ms>)
    let as_of = if upper.contains("AS OF SYSTEM TIME") {
        let ms_idx = parts
            .iter()
            .position(|w| w.to_uppercase() == "AS")
            .and_then(|i| {
                if parts.get(i + 1).map(|w| w.to_uppercase()).as_deref() == Some("OF")
                    && parts.get(i + 2).map(|w| w.to_uppercase()).as_deref() == Some("SYSTEM")
                    && parts.get(i + 3).map(|w| w.to_uppercase()).as_deref() == Some("TIME")
                {
                    Some(i + 4)
                } else {
                    None
                }
            });
        match ms_idx {
            Some(idx) => match parts.get(idx) {
                Some(tok) if tok.to_uppercase() == "LATEST" => CloneAsOf::Latest,
                Some(ms_str) => {
                    let ms = ms_str.parse::<i64>().map_err(|_| SqlError::Parse {
                        detail: format!(
                            "CLONE DATABASE AS OF SYSTEM TIME: expected integer milliseconds \
                             or LATEST, got '{ms_str}'"
                        ),
                    })?;
                    CloneAsOf::SystemTimeMs(ms)
                }
                None => {
                    return Err(SqlError::Parse {
                        detail: "CLONE DATABASE AS OF SYSTEM TIME requires a timestamp or LATEST"
                            .into(),
                    });
                }
            },
            None => CloneAsOf::Latest,
        }
    } else {
        CloneAsOf::Latest
    };

    Ok(NodedbStatement::CloneDatabase {
        new_name,
        source_name,
        as_of,
    })
}

#[cfg(test)]
mod tests {
    use super::super::dispatch::try_parse;
    use super::*;

    fn ok(sql: &str) -> NodedbStatement {
        let upper = sql.to_uppercase();
        let parts: Vec<&str> = sql.split_whitespace().collect();
        try_parse(&upper, &parts, sql)
            .expect("expected Some")
            .expect("expected Ok")
    }

    #[test]
    fn parse_clone_database_as_of_system_time() {
        let stmt = ok("CLONE DATABASE newdb FROM srcdb AS OF SYSTEM TIME 1730000000000");
        assert_eq!(
            stmt,
            NodedbStatement::CloneDatabase {
                new_name: "newdb".into(),
                source_name: "srcdb".into(),
                as_of: CloneAsOf::SystemTimeMs(1_730_000_000_000),
            }
        );
    }

    #[test]
    fn parse_clone_database_latest() {
        let stmt = ok("CLONE DATABASE newdb FROM srcdb AS OF LATEST");
        assert_eq!(
            stmt,
            NodedbStatement::CloneDatabase {
                new_name: "newdb".into(),
                source_name: "srcdb".into(),
                as_of: CloneAsOf::Latest,
            }
        );
    }

    #[test]
    fn parse_clone_database_no_as_of_defaults_to_latest() {
        let stmt = ok("CLONE DATABASE newdb FROM srcdb");
        assert_eq!(
            stmt,
            NodedbStatement::CloneDatabase {
                new_name: "newdb".into(),
                source_name: "srcdb".into(),
                as_of: CloneAsOf::Latest,
            }
        );
    }
}