aedb 0.2.13

Embedded Rust storage engine with transactional commits, WAL durability, and snapshot-consistent reads
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

use super::tests::{execute_query, setup};
use crate::catalog::schema::{ColumnDef, TableSchema};
use crate::catalog::types::{ColumnType, Value};
use crate::query::error::QueryError;
use crate::query::plan::{Aggregate, Expr, Order, Query};

fn validation_schema_with_columns(count: usize) -> TableSchema {
    TableSchema {
        project_id: "A".into(),
        scope_id: "app".into(),
        table_name: "wide".into(),
        owner_id: None,
        columns: (0..count)
            .map(|idx| ColumnDef {
                name: format!("c{idx}"),
                col_type: ColumnType::Integer,
                nullable: false,
            })
            .collect(),
        primary_key: vec!["c0".into()],
        constraints: Vec::new(),
        foreign_keys: Vec::new(),
    }
}

#[test]
fn type_mismatch_rejected_at_plan_time() {
    let (keyspace, catalog) = setup();
    let snapshot = keyspace.snapshot();
    let err = execute_query(
        &snapshot,
        &catalog,
        "A",
        "app",
        Query::select(&["*"])
            .from("users")
            .where_(Expr::Gt("age".into(), Value::Text("oops".into()))),
    )
    .expect_err("type mismatch");
    assert!(matches!(err, QueryError::TypeMismatch { .. }));
}

#[test]
fn validate_query_rejects_too_many_order_by_columns() {
    let schema = validation_schema_with_columns(33);
    let mut query = Query::select(&["*"]).from("wide");
    query.order_by = (0..33).map(|idx| (format!("c{idx}"), Order::Asc)).collect();

    let err = super::validate::validate_query(&schema, &query).expect_err("too many order by");
    assert!(matches!(err, QueryError::InvalidQuery { .. }));
}

#[test]
fn validate_query_rejects_too_many_group_by_columns() {
    let schema = validation_schema_with_columns(33);
    let mut query = Query::select(&["c0"]).from("wide");
    query.group_by = (0..33).map(|idx| format!("c{idx}")).collect();

    let err = super::validate::validate_query(&schema, &query).expect_err("too many group by");
    assert!(matches!(err, QueryError::InvalidQuery { .. }));
}

#[test]
fn validate_query_rejects_too_many_aggregates() {
    let schema = validation_schema_with_columns(1);
    let mut query = Query::select(&["count_star"]).from("wide");
    query.aggregates = (0..33).map(|_| Aggregate::Count).collect();

    let err = super::validate::validate_query(&schema, &query).expect_err("too many aggregates");
    assert!(matches!(err, QueryError::InvalidQuery { .. }));
}

#[test]
fn contradictory_pk_equalities_return_empty_result() {
    let (keyspace, catalog) = setup();
    let snapshot = keyspace.snapshot();
    let result = execute_query(
        &snapshot,
        &catalog,
        "A",
        "app",
        Query::select(&["id"])
            .from("users")
            .where_(
                Expr::Eq("id".into(), Value::Integer(1))
                    .and(Expr::Eq("id".into(), Value::Integer(2))),
            )
            .limit(10),
    )
    .expect("query");
    assert!(result.rows.is_empty());
}