dbx-core 0.2.2

High-performance file-based database engine with 5-Tier Hybrid Storage
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
118
119
120
121
122
123
124
125
126
127
128

//! API 트레이트 정의

use crate::error::DbxResult;
use arrow::array::{Array, ArrayRef, RecordBatch};
use arrow::datatypes::DataType;

/// RecordBatch에서 구조체로 변환하는 트레이트
pub trait FromRow: Sized {
    fn from_row(batch: &RecordBatch, row_idx: usize) -> DbxResult<Self>;
}

/// Rust 타입을 Arrow DataType으로 변환하는 트레이트
pub trait IntoArrowType {
    fn arrow_type() -> DataType;
    fn is_nullable() -> bool;
}

/// Arrow Array에서 Rust 타입으로 변환하는 트레이트
pub trait FromColumn: Sized {
    fn from_column(column: &ArrayRef, row_idx: usize) -> DbxResult<Self>;
}

// 기본 타입 구현
impl IntoArrowType for i32 {
    fn arrow_type() -> DataType {
        DataType::Int32
    }
    fn is_nullable() -> bool {
        false
    }
}

impl FromColumn for i32 {
    fn from_column(column: &ArrayRef, row_idx: usize) -> DbxResult<Self> {
        use arrow::array::AsArray;
        Ok(column
            .as_primitive::<arrow::datatypes::Int32Type>()
            .value(row_idx))
    }
}

impl IntoArrowType for i64 {
    fn arrow_type() -> DataType {
        DataType::Int64
    }
    fn is_nullable() -> bool {
        false
    }
}

impl FromColumn for i64 {
    fn from_column(column: &ArrayRef, row_idx: usize) -> DbxResult<Self> {
        use arrow::array::AsArray;
        Ok(column
            .as_primitive::<arrow::datatypes::Int64Type>()
            .value(row_idx))
    }
}

impl IntoArrowType for f64 {
    fn arrow_type() -> DataType {
        DataType::Float64
    }
    fn is_nullable() -> bool {
        false
    }
}

impl FromColumn for f64 {
    fn from_column(column: &ArrayRef, row_idx: usize) -> DbxResult<Self> {
        use arrow::array::AsArray;
        Ok(column
            .as_primitive::<arrow::datatypes::Float64Type>()
            .value(row_idx))
    }
}

impl IntoArrowType for String {
    fn arrow_type() -> DataType {
        DataType::Utf8
    }
    fn is_nullable() -> bool {
        false
    }
}

impl FromColumn for String {
    fn from_column(column: &ArrayRef, row_idx: usize) -> DbxResult<Self> {
        use arrow::array::AsArray;
        Ok(column.as_string::<i32>().value(row_idx).to_string())
    }
}

impl IntoArrowType for bool {
    fn arrow_type() -> DataType {
        DataType::Boolean
    }
    fn is_nullable() -> bool {
        false
    }
}

impl FromColumn for bool {
    fn from_column(column: &ArrayRef, row_idx: usize) -> DbxResult<Self> {
        use arrow::array::AsArray;
        Ok(column.as_boolean().value(row_idx))
    }
}

// Option<T> 구현
impl<T: IntoArrowType> IntoArrowType for Option<T> {
    fn arrow_type() -> DataType {
        T::arrow_type()
    }
    fn is_nullable() -> bool {
        true
    }
}

impl<T: FromColumn> FromColumn for Option<T> {
    fn from_column(column: &ArrayRef, row_idx: usize) -> DbxResult<Self> {
        if column.is_null(row_idx) {
            Ok(None)
        } else {
            Ok(Some(T::from_column(column, row_idx)?))
        }
    }
}