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

use icepick::arrow_convert::schema_to_arrow;
use icepick::spec::types::{ListType, MapType, StructType};
use icepick::spec::{NestedField, PrimitiveType, Schema, Type};

use arrow::datatypes::DataType;

#[test]
fn test_schema_to_arrow_simple() {
    let schema = Schema::builder()
        .with_fields(vec![
            NestedField::required_field(1, "id".to_string(), Type::Primitive(PrimitiveType::Long)),
            NestedField::optional_field(
                2,
                "name".to_string(),
                Type::Primitive(PrimitiveType::String),
            ),
        ])
        .build()
        .unwrap();

    let arrow_schema = schema_to_arrow(&schema).unwrap();

    assert_eq!(arrow_schema.fields().len(), 2);
    assert_eq!(arrow_schema.field(0).name(), "id");
    assert_eq!(arrow_schema.field(1).name(), "name");
    assert!(!arrow_schema.field(0).is_nullable());
    assert!(arrow_schema.field(1).is_nullable());
}

#[test]
fn test_schema_to_arrow_nested_types() {
    let schema = Schema::builder()
        .with_fields(vec![
            NestedField::optional_field(
                1,
                "items".to_string(),
                Type::List(ListType::new(4, false, Type::Primitive(PrimitiveType::Int))),
            ),
            NestedField::required_field(
                2,
                "attrs".to_string(),
                Type::Map(MapType::new(
                    5,
                    Type::Primitive(PrimitiveType::String),
                    6,
                    false,
                    Type::Primitive(PrimitiveType::String),
                )),
            ),
            NestedField::required_field(
                3,
                "price".to_string(),
                Type::Primitive(PrimitiveType::Decimal {
                    precision: 38,
                    scale: 4,
                }),
            ),
            NestedField::required_field(
                4,
                "inner".to_string(),
                Type::Struct(StructType::new(vec![NestedField::required_field(
                    5,
                    "value".to_string(),
                    Type::Primitive(PrimitiveType::Long),
                )])),
            ),
        ])
        .build()
        .unwrap();

    let arrow_schema = schema_to_arrow(&schema).unwrap();
    assert!(matches!(
        arrow_schema.field(0).data_type(),
        DataType::List(_)
    ));
    assert!(matches!(
        arrow_schema.field(1).data_type(),
        DataType::Map(_, _)
    ));
    assert_eq!(
        arrow_schema.field(2).data_type(),
        &DataType::Decimal128(38, 4)
    );
    assert!(matches!(
        arrow_schema.field(3).data_type(),
        DataType::Struct(_)
    ));
}