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
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

use osirisdb::ast::{
    ColumnConstraint, ColumnDef, CreateDatabaseStmt, CreateSchemaStmt, CreateTableStmt, DataType,
    ObjectName, Value,
};
use osirisdb::binder::Binder;
use osirisdb::catalog::CatalogManager;
use osirisdb::common::interner::Interner;
use osirisdb::common::symbol::Symbol;
use osirisdb::executor::{ExecutionResult, Executor};
use osirisdb::storage::Storage;
use std::env;
use std::path::{Path, PathBuf};

fn tmp(name: &str) -> PathBuf {
    env::temp_dir().join(format!("osirisdb_exec_constraint_{}", name))
}

fn rm(path: &Path) {
    let _ = std::fs::remove_dir_all(path);
}

#[test]
fn test_primary_key_uniqueness() {
    let path = tmp("pk_uniq");
    rm(&path);

    let mut interner = Interner::new();
    let db_sym = interner.intern("mydb");
    let schema_sym = interner.intern("myschema");
    let table_sym = interner.intern("users");
    let col_id = interner.intern("id");
    let col_name = interner.intern("name");
    let user_sym = interner.intern("postgres");

    let catalog = CatalogManager::new(interner);
    let storage = Storage::new_or_create(&path).unwrap();
    let mut executor = Executor::new(catalog, user_sym, storage);

    // 1. Create DB, Schema, and Table with PRIMARY KEY
    executor
        .execute_create_database(osirisdb::binder::bound::database::BoundCreateDatabaseStmt {
            name: db_sym,
            if_not_exists: true,
            owner: user_sym,
            encoding: None,
            locale: None,
            tablespace: None,
            connection_limit: None,
        })
        .unwrap();

    executor
        .execute_create_schema(
            db_sym,
            osirisdb::binder::bound::schema::BoundCreateSchemaStmt {
                name: Some(schema_sym),
                authorization: None,
                if_not_exists: true,
            },
        )
        .unwrap();

    let columns = vec![
        ColumnDef {
            name: col_id,
            data_type: DataType::Int,
            collation: None,
            constraints: vec![ColumnConstraint::PrimaryKey],
            generated: None,
        },
        ColumnDef {
            name: col_name,
            data_type: DataType::VarChar(Some(255)),
            collation: None,
            constraints: vec![],
            generated: None,
        },
    ];

    let binder = Binder::new(&executor.catalog, user_sym);
    let bound_create = binder
        .bind_create_table(
            db_sym,
            schema_sym,
            CreateTableStmt {
                if_not_exist: false,
                temporary: false,
                unlogged: false,
                name: ObjectName(vec![schema_sym, table_sym]),
                columns,
                constraints: vec![],
                inherits: vec![],
                partitions: vec![],
                with_options: vec![],
                table_space: None,
                on_commit: None,
                as_query: None,
            },
        )
        .unwrap();

    executor.execute_create_table(bound_create).unwrap();

    // 2. Insert first row (ID: 1)
    let bound_insert1 = osirisdb::binder::bound::insert::BoundInsertStmt {
        db: db_sym,
        schema: schema_sym,
        table: table_sym,
        rows: vec![vec![Value::Int(1), Value::String(user_sym)]],
    };
    executor.execute_insert_table(bound_insert1).unwrap();

    // 3. Attempt to insert duplicate row (ID: 1) - should fail
    let bound_insert2 = osirisdb::binder::bound::insert::BoundInsertStmt {
        db: db_sym,
        schema: schema_sym,
        table: table_sym,
        rows: vec![vec![Value::Int(1), Value::String(user_sym)]],
    };
    let err = executor.execute_insert_table(bound_insert2).unwrap_err();
    assert!(err.to_string().contains("duplicate key value"));

    rm(&path);
}