icydb-core 0.276.0

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

//! Module: session::response::grouped
//! Responsibility: grouped paged response finalization.
//! Does not own: grouped execution, aggregate evaluation, or public response DTO shape.
//! Boundary: converts executor grouped results into public grouped page envelopes.

use crate::db::cursor::encode_cursor;
use crate::db::{
    GroupedRow, QueryError,
    executor::{RuntimeGroupedRow, StructuralGroupedProjectionResult},
    schema::AcceptedEnumCatalog,
    session::response::output_row_from_runtime,
};

/// Grouped rows and an optional encoded continuation.
type FinalizedGroupedProjection = (Vec<GroupedRow>, Option<Vec<u8>>);

// Convert one executor-owned grouped runtime carrier into the public grouped row
// DTO at the session boundary. This preserves `db::response` as DTO-only while
// keeping executor internals out of public response construction.
fn grouped_row_from_runtime_row(
    catalog: &AcceptedEnumCatalog,
    row: RuntimeGroupedRow,
) -> Result<GroupedRow, QueryError> {
    let (group_key, aggregate_values) = row.into_group_key_and_aggregate_values();
    let group_key = output_row_from_runtime(catalog, group_key)?;
    let aggregate_values = output_row_from_runtime(catalog, aggregate_values)?;

    Ok(GroupedRow::new(group_key, aggregate_values))
}

// Convert one ordered executor grouped page row vector without changing row
// order. SQL and fluent grouped response finalizers both use this adapter.
fn grouped_rows_from_runtime_rows(
    catalog: &AcceptedEnumCatalog,
    rows: Vec<RuntimeGroupedRow>,
) -> Result<Vec<GroupedRow>, QueryError> {
    rows.into_iter()
        .map(|row| grouped_row_from_runtime_row(catalog, row))
        .collect()
}

// Finalize one executor-owned structural grouped projection result for response
// shaping without exposing grouped cursor-page fields to session callers.
pub(in crate::db) fn finalize_structural_grouped_projection_result(
    result: StructuralGroupedProjectionResult,
) -> Result<FinalizedGroupedProjection, QueryError> {
    let (rows, next_cursor, value_catalog) = result.into_rows_and_cursor();
    let rows = grouped_rows_from_runtime_rows(value_catalog.enum_catalog(), rows)?;

    Ok((rows, next_cursor))
}

// Convert core grouped cursor bytes into the query surface's external cursor
// string. The byte payload already came from the cursor-owned grouped encoder,
// so this is only unpadded URL-safe Base64 display formatting.
pub(in crate::db) fn grouped_cursor_from_bytes(cursor: Option<Vec<u8>>) -> Option<String> {
    cursor.as_deref().map(encode_cursor)
}