icydb-core 0.94.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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//! Module: contracts::semantics
//! Responsibility: canonical cross-subsystem value ordering contracts.
//! Does not own: predicate truth semantics or query planning policy.
//! Boundary: provides ordering-only helpers for sort/range/cursor surfaces.

use crate::{db::numeric::compare_numeric_or_strict_order, value::Value};
use std::cmp::Ordering;

///
/// OrderingSemantics
///
/// Explicit ordering contract used by sort/range/continuation paths.
/// Callers must not reuse this ordering surface for deduplication equality.
///

pub(in crate::db) trait OrderingSemantics<T: ?Sized> {
    /// Compare two values under this semantics contract.
    fn compare(left: &T, right: &T) -> Ordering;
}

///
/// CanonicalValueOrderingSemantics
///
/// Canonical total ordering for `Value` sort/range/cursor boundaries.
/// Numeric-capable pairs delegate to shared numeric-or-strict comparison first.
///

pub(in crate::db) struct CanonicalValueOrderingSemantics;

impl OrderingSemantics<Value> for CanonicalValueOrderingSemantics {
    fn compare(left: &Value, right: &Value) -> Ordering {
        if let Some(ordering) = compare_numeric_or_strict_order(left, right) {
            return ordering;
        }

        Value::canonical_cmp(left, right)
    }
}

/// Compare two values with canonical ordering semantics.
#[must_use]
pub(in crate::db) fn canonical_value_compare(left: &Value, right: &Value) -> Ordering {
    CanonicalValueOrderingSemantics::compare(left, right)
}

///
/// TESTS
///

#[cfg(test)]
mod tests {
    use crate::{db::contracts::canonical_value_compare, value::Value};
    use std::cmp::Ordering;

    #[test]
    fn canonical_value_ordering_uses_value_canonical_order() {
        assert_eq!(
            canonical_value_compare(&Value::Uint(7), &Value::Uint(8)),
            Ordering::Less
        );
        assert_eq!(
            canonical_value_compare(&Value::Text("x".to_string()), &Value::Text("x".to_string())),
            Ordering::Equal
        );
    }

    #[test]
    fn canonical_value_ordering_prefers_shared_numeric_or_strict_authority() {
        assert_eq!(
            canonical_value_compare(&Value::Int(7), &Value::Uint(7)),
            Ordering::Equal
        );
    }
}