icepick 0.1.0

Experimental Rust client for Apache Iceberg with WASM support for AWS S3 Tables and Cloudflare R2
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

use icepick::spec::types::{NestedField, PrimitiveType, StructType, Type};

#[test]
fn test_primitive_type_boolean() {
    let t = Type::Primitive(PrimitiveType::Boolean);
    assert!(matches!(t, Type::Primitive(PrimitiveType::Boolean)));
}

#[test]
fn test_primitive_type_integer() {
    let t = Type::Primitive(PrimitiveType::Int);
    assert!(matches!(t, Type::Primitive(PrimitiveType::Int)));
}

#[test]
fn test_primitive_type_long() {
    let t = Type::Primitive(PrimitiveType::Long);
    assert!(matches!(t, Type::Primitive(PrimitiveType::Long)));
}

#[test]
fn test_primitive_type_string() {
    let t = Type::Primitive(PrimitiveType::String);
    assert!(matches!(t, Type::Primitive(PrimitiveType::String)));
}

#[test]
fn test_primitive_type_binary() {
    let t = Type::Primitive(PrimitiveType::Binary);
    assert!(matches!(t, Type::Primitive(PrimitiveType::Binary)));
}

#[test]
fn test_nested_field_required() {
    let field = NestedField::new(
        1,
        "id".to_string(),
        Type::Primitive(PrimitiveType::Long),
        true,
        None,
    );

    assert_eq!(field.id(), 1);
    assert_eq!(field.name(), "id");
    assert!(field.is_required());
    assert!(matches!(
        field.field_type(),
        Type::Primitive(PrimitiveType::Long)
    ));
}

#[test]
fn test_nested_field_optional_with_doc() {
    let field = NestedField::new(
        2,
        "email".to_string(),
        Type::Primitive(PrimitiveType::String),
        false,
        Some("User email address".to_string()),
    );

    assert_eq!(field.id(), 2);
    assert!(!field.is_required());
    assert_eq!(field.doc(), Some("User email address"));
}

#[test]
fn test_struct_type_simple() {
    let fields = vec![
        NestedField::required_field(1, "id".to_string(), Type::Primitive(PrimitiveType::Long)),
        NestedField::required_field(
            2,
            "name".to_string(),
            Type::Primitive(PrimitiveType::String),
        ),
    ];

    let struct_type = StructType::new(fields.clone());
    assert_eq!(struct_type.fields().len(), 2);
    assert_eq!(struct_type.fields()[0].name(), "id");
    assert_eq!(struct_type.fields()[1].name(), "name");
}

#[test]
fn test_struct_type_nested() {
    let address_fields = vec![
        NestedField::required_field(
            3,
            "street".to_string(),
            Type::Primitive(PrimitiveType::String),
        ),
        NestedField::optional_field(
            4,
            "city".to_string(),
            Type::Primitive(PrimitiveType::String),
        ),
    ];

    let fields = vec![
        NestedField::required_field(1, "id".to_string(), Type::Primitive(PrimitiveType::Long)),
        NestedField::optional_field(
            2,
            "address".to_string(),
            Type::Struct(StructType::new(address_fields)),
        ),
    ];

    let struct_type = StructType::new(fields);
    assert_eq!(struct_type.fields().len(), 2);

    // Check nested struct
    if let Type::Struct(nested) = struct_type.fields()[1].field_type() {
        assert_eq!(nested.fields().len(), 2);
    } else {
        panic!("Expected nested struct");
    }
}