icydb-core 0.252.3

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

//! SQL output payload attribution DTOs and builders.
//! Does not own: SQL response shaping or public row rendering.

use crate::{
    db::session::sql::result::SqlStatementResult,
    value::{OutputValue, PublicValue},
};
use candid::CandidType;
use serde::Deserialize;

///
/// SqlOutputBlobAttribution
///
/// Candid diagnostics payload for SQL projection payload size. Raw bytes count
/// the blob bytes projected into SQL output values; rendered hex bytes count
/// the blob-specific `0x...` text that public SQL row rendering will emit.
///

#[derive(CandidType, Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq)]
pub struct SqlOutputBlobAttribution {
    pub projected_values: u64,
    pub projected_bytes: u64,
    pub rendered_hex_bytes: u64,
}

pub(super) fn sql_output_blob_attribution(result: &SqlStatementResult) -> SqlOutputBlobAttribution {
    let mut attribution = SqlOutputBlobAttribution::default();

    match result {
        SqlStatementResult::Projection { rows, .. } => {
            for row in rows {
                for value in row {
                    record_output_value_blob_attribution(value, &mut attribution);
                }
            }
        }
        SqlStatementResult::Grouped { rows, .. } => {
            for row in rows {
                for value in row.group_key().iter().chain(row.aggregate_values()) {
                    record_output_value_blob_attribution(value, &mut attribution);
                }
            }
        }
        SqlStatementResult::Count { .. }
        | SqlStatementResult::Describe(_)
        | SqlStatementResult::ShowConstraints(_)
        | SqlStatementResult::ShowIndexes(_)
        | SqlStatementResult::ShowColumns(_)
        | SqlStatementResult::ShowRelations(_)
        | SqlStatementResult::ShowEntities { .. }
        | SqlStatementResult::ShowStores { .. }
        | SqlStatementResult::ShowMemory(_)
        | SqlStatementResult::Ddl(_) => {}
        #[cfg(feature = "sql")]
        SqlStatementResult::Explain(_) => {}
    }

    attribution
}

fn record_output_value_blob_attribution(
    value: &OutputValue,
    attribution: &mut SqlOutputBlobAttribution,
) {
    record_public_value_blob_attribution(value.as_public(), attribution);
}

fn record_public_value_blob_attribution(
    value: &PublicValue,
    attribution: &mut SqlOutputBlobAttribution,
) {
    match value {
        PublicValue::Blob(bytes) => {
            let byte_len = u64::try_from(bytes.len()).unwrap_or(u64::MAX);
            attribution.projected_values = attribution.projected_values.saturating_add(1);
            attribution.projected_bytes = attribution.projected_bytes.saturating_add(byte_len);
            attribution.rendered_hex_bytes = attribution
                .rendered_hex_bytes
                .saturating_add(byte_len.saturating_mul(2).saturating_add(2));
        }
        PublicValue::Enum(value) => {
            if let Some(payload) = value.payload() {
                record_public_value_blob_attribution(payload, attribution);
            }
        }
        PublicValue::List(items) => {
            for item in items {
                record_public_value_blob_attribution(item, attribution);
            }
        }
        PublicValue::Map(entries) => {
            for (key, value) in entries {
                record_public_value_blob_attribution(key, attribution);
                record_public_value_blob_attribution(value, attribution);
            }
        }
        PublicValue::Account(_)
        | PublicValue::Bool(_)
        | PublicValue::Date(_)
        | PublicValue::Decimal(_)
        | PublicValue::Duration(_)
        | PublicValue::Float32(_)
        | PublicValue::Float64(_)
        | PublicValue::Int64(_)
        | PublicValue::Int128(_)
        | PublicValue::IntBig(_)
        | PublicValue::Null
        | PublicValue::Principal(_)
        | PublicValue::Subaccount(_)
        | PublicValue::Text(_)
        | PublicValue::Timestamp(_)
        | PublicValue::Nat64(_)
        | PublicValue::Nat128(_)
        | PublicValue::NatBig(_)
        | PublicValue::Ulid(_)
        | PublicValue::Unit
        | PublicValue::U256(_) => {}
    }
}