schema_analysis 0.7.0

Analyze the schema of any self describing format
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

use bson::bson;

use schema_analysis::InferredSchema;

mod shared;
use shared::FormatTests;

struct Bson;

test_format!(Bson);

impl FormatTests for Bson {
    type Value = bson::Bson;

    fn infer_schema(value: Self::Value) -> InferredSchema {
        let bytes = bson::to_vec(&value).unwrap();
        let processed_schema: InferredSchema = bson::from_slice(&bytes).unwrap();
        processed_schema
    }

    // Bson doesn't allow top-level primitives
    fn test_null() {}
    fn null() -> Self::Value {
        unreachable!()
    }
    fn test_boolean() {}
    fn boolean() -> Self::Value {
        unreachable!()
    }
    fn test_integer() {}
    fn integer() -> Self::Value {
        unreachable!()
    }
    fn test_float() {}
    fn float() -> Self::Value {
        unreachable!()
    }
    fn test_string() {}
    fn string() -> Self::Value {
        unreachable!()
    }

    // Bson doesn't allow top-level arrays
    fn test_empty_sequence() {}
    fn empty_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_string_sequence() {}
    fn string_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_integer_sequence() {}
    fn integer_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_mixed_sequence() {}
    fn mixed_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_optional_mixed_sequence() {}
    fn optional_mixed_sequence() -> Self::Value {
        unreachable!()
    }

    fn empty_map_struct() -> Self::Value {
        bson!({})
    }
    fn map_struct_single() -> Self::Value {
        bson!({
            "hello": 1
        })
    }
    fn map_struct_double() -> Self::Value {
        bson!({
            "hello": 1,
            "world": "!"
        })
    }
    fn test_sequence_map_struct_mixed() {}
    fn sequence_map_struct_mixed() -> Self::Value {
        unreachable!() // Bson doesn't allow top-level arrays
    }
    fn test_sequence_map_struct_optional_or_missing() {}
    fn sequence_map_struct_optional_or_missing() -> Self::Value {
        unreachable!() // Bson doesn't allow top-level arrays
    }
    fn map_struct_mixed_sequence() -> Self::Value {
        bson!({
            "hello": 1,
            "world": "!",
            "sequence": ["one", "two", "three"]
        })
    }
    fn map_struct_mixed_sequence_optional() -> Self::Value {
        bson!({
            "hello": 1,
            "world": "!",
            "optional": null,
            "sequence": ["one", "two", "three", null]
        })
    }
}