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

use crate::{
    binder::bound::BoundCreateTableStmt,
    executor::{ExecutionError, ExecutionResult, Executor},
};

impl Executor {
    /// Executes a `CREATE TABLE` statement.
    ///
    /// Receives a fully bound and validated statement from the binder —
    /// no further validation is performed here.
    ///
    /// # Steps
    ///
    /// 1. Writes the table entry (columns + table-level constraints) to
    ///    the catalog via `CatalogManager`
    /// 2. Creates the on-disk `.dat` file for the table (skipped in
    ///    memory-only mode)
    /// 3. Persists metadata to the system catalog
    ///
    /// # Errors
    ///
    /// Returns [`ExecutionError::Catalog`] if the catalog rejects the operation.
    /// Returns [`ExecutionError::Storage`] if the on-disk creation fails.
    pub fn execute_create_table(
        &mut self,
        stmt: BoundCreateTableStmt,
    ) -> Result<ExecutionResult, ExecutionError> {
        let name = stmt.name;
        let db_sym = stmt.db;
        let schema_sym = stmt.schema;

        // Resolve names before catalog mutation takes ownership of stmt.
        let db_name = self.catalog.interner.resolve(db_sym).to_string();
        let schema_name = self.catalog.interner.resolve(schema_sym).to_string();
        let table_name = self.catalog.interner.resolve(name).to_string();

        let storage = self
            .storage
            .as_ref()
            .ok_or_else(|| ExecutionError::Storage("storage engine not initialized".to_string()))?;

        // 1. Create on-disk table file.
        if !self.catalog.table_exists(db_sym, schema_sym, stmt.name) {
            storage
                .create_table_file(&db_name, &schema_name, &table_name)
                .map_err(|e| ExecutionError::Storage(e.to_string()))?;
        }

        // 2. Insert table entry into the catalog.
        self.catalog
            .create_table(
                storage,
                db_sym,
                schema_sym,
                stmt.name,
                stmt.columns,
                stmt.constraints,
                stmt.if_not_exists,
            )
            .map_err(ExecutionError::from)?;

        // 3. Persist to system catalog.
        if let Some(sys) = &self.system_catalog {
            let entry = self
                .catalog
                .get_table(db_sym, schema_sym, name)
                .map_err(ExecutionError::from)?
                .clone();
            sys.write_table(&db_name, &schema_name, &entry, &mut self.catalog.interner)
                .map_err(|e| ExecutionError::Storage(e.to_string()))?;
        }

        Ok(ExecutionResult::TableCreated { name })
    }
}