graphar 0.1.1

Apache GraphAr format reader/writer
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

use arrow_schema::{DataType as ArrowDataType, Field, TimeUnit};
use serde::{Deserialize, Serialize};

use crate::error::{GraphArError, Result};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DataType {
    Bool,
    Int32,
    Int64,
    Float,
    Double,
    String,
    Date,
    Timestamp,
    Time,
    List,
}

impl DataType {
    pub fn to_arrow(&self, field_name: &str, nullable: bool) -> Field {
        let dt = match self {
            DataType::Bool => ArrowDataType::Boolean,
            DataType::Int32 => ArrowDataType::Int32,
            DataType::Int64 => ArrowDataType::Int64,
            DataType::Float => ArrowDataType::Float32,
            DataType::Double => ArrowDataType::Float64,
            DataType::String => ArrowDataType::Utf8,
            DataType::Date => ArrowDataType::Date32,
            DataType::Timestamp => ArrowDataType::Timestamp(TimeUnit::Millisecond, None),
            DataType::Time => ArrowDataType::Time64(TimeUnit::Millisecond),
            // A `list` property is written as a real Arrow `List<Utf8>` (see
            // `build_record_batch` in writer/vertex_writer.rs, which fills a
            // `ListBuilder<StringBuilder>`). The schema field must match that
            // `List(item: Utf8, nullable)` exactly, or `RecordBatch::try_new`
            // rejects the column.
            DataType::List => ArrowDataType::List(std::sync::Arc::new(Field::new(
                "item",
                ArrowDataType::Utf8,
                true,
            ))),
        };
        Field::new(field_name, dt, nullable)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum FileType {
    #[default]
    Parquet,
    Orc,
    Csv,
    Json,
    ArrowIpc,
}

impl FileType {
    pub fn extension(&self) -> &'static str {
        match self {
            FileType::Parquet => "parquet",
            FileType::Orc => "orc",
            FileType::Csv => "csv",
            FileType::Json => "json",
            FileType::ArrowIpc => "arrow",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AdjListType {
    OrderedBySource,
    OrderedByDest,
    UnorderedBySource,
    UnorderedByDest,
}

impl AdjListType {
    pub fn dir_name(&self) -> &'static str {
        match self {
            AdjListType::OrderedBySource => "ordered_by_source",
            AdjListType::OrderedByDest => "ordered_by_dest",
            AdjListType::UnorderedBySource => "unordered_by_source",
            AdjListType::UnorderedByDest => "unordered_by_dest",
        }
    }

    pub fn is_ordered(&self) -> bool {
        matches!(
            self,
            AdjListType::OrderedBySource | AdjListType::OrderedByDest
        )
    }

    pub fn aligned_by_src(&self) -> bool {
        matches!(
            self,
            AdjListType::OrderedBySource | AdjListType::UnorderedBySource
        )
    }
}

impl TryFrom<(&str, &str)> for AdjListType {
    type Error = GraphArError;

    fn try_from((ordered, aligned_by): (&str, &str)) -> Result<Self> {
        match (ordered, aligned_by) {
            ("true", "src") => Ok(AdjListType::OrderedBySource),
            ("true", "dst") => Ok(AdjListType::OrderedByDest),
            ("false", "src") => Ok(AdjListType::UnorderedBySource),
            ("false", "dst") => Ok(AdjListType::UnorderedByDest),
            _ => Err(GraphArError::InvalidAdjListType {
                ordered: ordered.to_string(),
                aligned_by: aligned_by.to_string(),
            }),
        }
    }
}