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
82
83
84
85
86
87

use crate::{
    ast::CreateDatabaseStmt,
    catalog::{
        error::CatalogError,
        manager::CatalogManager,
        objects::{SchemaEntry, database::DatabaseEntry},
    },
    common::symbol::Symbol,
};

impl CatalogManager {
    /// Executes a `CREATE DATABASE` statement against the catalog.
    ///
    /// # Behavior
    ///
    /// - Already exists + `IF NOT EXISTS` → silent success
    /// - Already exists + no `IF NOT EXISTS` → error
    /// - `OWNER` not specified → resolved to `session_user`
    pub fn create_database(
        &mut self,
        stmt: CreateDatabaseStmt,
        session_user: Symbol,
    ) -> Result<(), CatalogError> {
        if self.catalog.databases.contains_key(&stmt.name) {
            if stmt.if_not_exists {
                return Ok(());
            }
            return Err(CatalogError::DatabaseAlreadyExists(stmt.name));
        }

        let owner = stmt.owner.unwrap_or(session_user);
        let oid = self.catalog.next_oid();

        let entry = DatabaseEntry::new(
            oid,
            stmt.name,
            owner,
            stmt.encoding,
            stmt.locale,
            stmt.tablespace,
            stmt.connection_limit,
        );

        self.catalog.databases.insert(stmt.name, entry);

        // Every database gets a default `public` schema, mirroring the
        // `public/` directory storage creates alongside the database.
        let public = self.interner.intern("public");
        let public_oid = self.catalog.next_oid();
        let public_schema = SchemaEntry::new(public_oid, public, owner, stmt.name);
        self.catalog
            .databases
            .get_mut(&stmt.name)
            .unwrap()
            .schemas
            .insert(public, public_schema);
        Ok(())
    }

    /// Returns `true` if a database with the given name exists.
    pub fn database_exists(&self, name: Symbol) -> bool {
        self.catalog.databases.contains_key(&name)
    }

    /// Looks up a database by name.
    ///
    /// Returns [`CatalogError::DatabaseNotFound`] if it does not exist.
    pub fn get_database(&self, name: Symbol) -> Result<&DatabaseEntry, CatalogError> {
        self.catalog
            .databases
            .get(&name)
            .ok_or(CatalogError::DatabaseNotFound(name))
    }

    /// Drops a database from the catalog.
    ///
    /// Caller must ensure no active connections exist before calling.
    pub fn drop_database(&mut self, name: Symbol, if_exists: bool) -> Result<(), CatalogError> {
        if self.catalog.databases.remove(&name).is_none() {
            if if_exists {
                return Ok(());
            }
            return Err(CatalogError::DatabaseNotFound(name));
        }
        Ok(())
    }
}