fosk 0.1.14

In-memory SQL-like query engine and lightweight data store for testing and prototyping.
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

use serde::{Deserialize, Serialize};
use serde_json::Value;

/// Lightweight classification of JSON value shapes used by schema inference.
///
/// This enum represents the coarse-grained primitive kind of a JSON value
/// encountered while inspecting documents: Null, Bool, Int, Float, String,
/// Object (map) or Array.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum JsonPrimitive {
    /// JSON null
    Null,
    /// JSON boolean
    Bool,
    /// Integer number
    Int,
    /// Floating-point number
    Float,
    /// String
    String,
    /// JSON object (map)
    Object,
    /// JSON array
    Array,
}

impl JsonPrimitive {
    /// Classify a serde_json `Value` into a `JsonPrimitive`.
    ///
    /// Returns a single variant indicating the basic shape of the value.
    ///
    /// # Example
    ///
    /// ```
    /// use fosk::JsonPrimitive;
    /// use serde_json::json;
    ///
    /// assert_eq!(JsonPrimitive::of_value(&json!(42)), JsonPrimitive::Int);
    /// assert_eq!(JsonPrimitive::of_value(&json!(4.2)), JsonPrimitive::Float);
    /// assert_eq!(JsonPrimitive::of_value(&json!({ "ok": true })), JsonPrimitive::Object);
    /// ```
    pub fn of_value(v: &Value) -> JsonPrimitive {
        match v {
            Value::Null => JsonPrimitive::Null,
            Value::Bool(_) => JsonPrimitive::Bool,
            Value::Number(n) => {
                if n.is_i64() || n.is_u64() {
                    JsonPrimitive::Int
                } else {
                    JsonPrimitive::Float
                }
            }
            Value::String(_) => JsonPrimitive::String,
            Value::Array(_) => JsonPrimitive::Array,
            Value::Object(_) => JsonPrimitive::Object,
        }
    }

    /// Promote two primitive types to a common representative for schema merging.
    ///
    /// Numeric types promote `Int` + `Float` -> `Float`. For different
    /// non-numeric types the left-hand value is preserved except when it is
    /// `Null`, in which case the right-hand type is returned.
    ///
    /// # Example
    ///
    /// ```
    /// use fosk::JsonPrimitive;
    ///
    /// assert_eq!(
    ///     JsonPrimitive::promote(JsonPrimitive::Int, JsonPrimitive::Float),
    ///     JsonPrimitive::Float
    /// );
    /// ```
    pub fn promote(a: JsonPrimitive, b: JsonPrimitive) -> JsonPrimitive {
        use JsonPrimitive::*;
        if a == b {
            return a;
        }
        match (a, b) {
            (Int, Float) | (Float, Int) => Float,
            // Different non-numeric types stay as the left (first seen) type.
            // You can change this to a Mixed variant if you prefer.
            (x, y) => {
                // If one is Null, keep the other (nullability is tracked separately)
                if x == Null { y } else { x }
            }
        }
    }
}