icydb-core 0.264.2

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
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
138
139
140
141
142
143
144

//! Owned grouped attachment preparation under the existing request budget.

use super::newtype_query_schema;
use crate::{
    db::{
        QueryError,
        query::{
            plan::{
                AggregateKind, GroupedAggregateExecutionSpec, expr::Expr,
                grouped_aggregate_execution_specs,
            },
            preparation::PreparationWork,
        },
        test_support::request_with_limit,
    },
    value::Value,
};
use icydb_diagnostic_code::{
    DiagnosticExecutionBudgetResource as Resource, DiagnosticExecutionLane as Lane,
    DiagnosticFactTag,
};

fn count_rows() -> GroupedAggregateExecutionSpec {
    GroupedAggregateExecutionSpec::from_uncompiled_inputs(
        AggregateKind::Count,
        None,
        None,
        None,
        false,
    )
}

fn filtered_min() -> GroupedAggregateExecutionSpec {
    GroupedAggregateExecutionSpec::from_uncompiled_inputs(
        AggregateKind::Min,
        None,
        Some(Expr::Literal(Value::Text("abc".into()))),
        Some(Expr::Literal(Value::Bool(true))),
        true,
    )
}

fn assert_budget_error(error: QueryError, resource: Resource) {
    assert!(
        error
            .diagnostic_facts()
            .contains(&(DiagnosticFactTag::BudgetResource, resource.raw()))
    );
}

#[test]
fn count_attachments_reuse_list_capacity_without_new_backing() {
    let schema = newtype_query_schema();
    let mut specs = Vec::with_capacity(8);
    specs.extend([count_rows(), count_rows()]);
    let pointer = specs.as_ptr();
    let capacity = specs.capacity();
    let request = request_with_limit(Resource::TemporaryBytes, 0);
    let resolved = PreparationWork::run(&request.scope(), Lane::Diagnostic, |work| {
        grouped_aggregate_execution_specs(&schema, specs, work).map_err(QueryError::execute)
    })
    .unwrap();
    assert_eq!(resolved.as_ptr(), pointer);
    assert_eq!(resolved.capacity(), capacity);
    assert_eq!(resolved, [count_rows(), count_rows()]);
    assert_eq!(request.observed(Resource::TemporaryBytes), 0);
    assert_eq!(request.observed(Resource::PredicateExpressionSteps), 2);
}

#[test]
fn attachment_compilation_keeps_owned_syntax_and_charges_only_compiled_payloads() {
    let schema = newtype_query_schema();
    let spec = filtered_min();
    let expected = spec.clone();
    let Some(Expr::Literal(Value::Text(text))) = spec.input_expr() else {
        panic!("text input");
    };
    let pointer = text.as_ptr();
    let specs = vec![spec];
    let request = request_with_limit(Resource::TemporaryBytes, 3);
    let resolved = PreparationWork::run(&request.scope(), Lane::PublicRead, |work| {
        grouped_aggregate_execution_specs(&schema, specs, work).map_err(QueryError::execute)
    })
    .unwrap();
    let resolved = &resolved[0];
    let Some(Expr::Literal(Value::Text(text))) = resolved.input_expr() else {
        panic!("text input");
    };
    assert_eq!(text.as_ptr(), pointer);
    assert_eq!(resolved.semantic_key(), expected.semantic_key());
    assert_eq!(resolved.filter_expr(), expected.filter_expr());
    assert!(resolved.compiled_input_expr().is_some());
    assert!(resolved.compiled_filter_expr().is_some());
    assert!(!resolved.distinct());
    assert_eq!(request.observed(Resource::TemporaryBytes), 3);

    let specs = vec![filtered_min()];
    let rejected = request_with_limit(Resource::TemporaryBytes, 2);
    let error = PreparationWork::run(&rejected.scope(), Lane::PublicRead, |work| {
        grouped_aggregate_execution_specs(&schema, specs, work).map_err(QueryError::execute)
    })
    .unwrap_err();
    assert_budget_error(error, Resource::TemporaryBytes);
}

#[test]
fn failed_filter_compilation_does_not_publish_partial_attachments() {
    let schema = newtype_query_schema();
    let mut spec = filtered_min();
    let original = spec.clone();
    // One spec visit plus the text input's four steps fits; its filter does not.
    let request = request_with_limit(Resource::PredicateExpressionSteps, 5);
    let error = PreparationWork::run(&request.scope(), Lane::Diagnostic, |work| {
        spec.resolve_with_schema_info(&schema, work)
            .map_err(QueryError::execute)
    })
    .unwrap_err();
    assert_budget_error(error, Resource::PredicateExpressionSteps);
    assert_eq!(spec, original);
    assert_eq!(request.observed(Resource::TemporaryBytes), 3);
}

#[test]
fn attachment_visits_are_cumulative_and_empty_lists_are_free() {
    let schema = newtype_query_schema();
    for lane in [Lane::PublicRead, Lane::Diagnostic] {
        let request = request_with_limit(Resource::PredicateExpressionSteps, 1);
        let error = PreparationWork::run(&request.scope(), lane, |work| {
            assert!(
                grouped_aggregate_execution_specs(&schema, Vec::new(), work)
                    .map_err(QueryError::execute)?
                    .is_empty()
            );
            let first = grouped_aggregate_execution_specs(&schema, vec![count_rows()], work)
                .map_err(QueryError::execute)?;
            assert_eq!(first.len(), 1);
            grouped_aggregate_execution_specs(&schema, vec![count_rows()], work)
                .map_err(QueryError::execute)
        })
        .unwrap_err();
        assert_budget_error(error, Resource::PredicateExpressionSteps);
        assert_eq!(request.observed(Resource::PredicateExpressionSteps), 2);
    }
}