alopex-dataframe 0.7.2

Polars-compatible DataFrame API for Alopex DB (v0.1)
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::Expr;

/// Options for reading CSV files.
#[derive(Debug, Clone)]
pub struct CsvReadOptions {
    /// Whether the CSV file has a header row.
    pub has_header: bool,
    /// Field delimiter byte (e.g. `b','`).
    pub delimiter: u8,
    /// Quote character byte (defaults to `Some(b'\"')`).
    pub quote_char: Option<u8>,
    /// Values that should be interpreted as null.
    pub null_values: Vec<String>,
    /// Maximum number of rows used for schema inference.
    pub infer_schema_length: usize,
    /// Optional column projection (names).
    pub projection: Option<Vec<String>>,
    /// Optional predicate expression to apply (may be pushed down in the future).
    pub predicate: Option<Expr>,
}

impl Default for CsvReadOptions {
    fn default() -> Self {
        Self {
            has_header: true,
            delimiter: b',',
            quote_char: Some(b'"'),
            null_values: Vec::new(),
            infer_schema_length: 100,
            projection: None,
            predicate: None,
        }
    }
}

impl CsvReadOptions {
    /// Set `has_header`.
    pub fn with_has_header(mut self, has_header: bool) -> Self {
        self.has_header = has_header;
        self
    }

    /// Set `delimiter`.
    pub fn with_delimiter(mut self, delimiter: u8) -> Self {
        self.delimiter = delimiter;
        self
    }

    /// Set `quote_char`.
    pub fn with_quote_char(mut self, quote_char: Option<u8>) -> Self {
        self.quote_char = quote_char;
        self
    }

    /// Set `null_values`.
    pub fn with_null_values<I, S>(mut self, values: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: Into<String>,
    {
        self.null_values = values.into_iter().map(Into::into).collect();
        self
    }

    /// Set `infer_schema_length`.
    pub fn with_infer_schema_length(mut self, infer_schema_length: usize) -> Self {
        self.infer_schema_length = infer_schema_length;
        self
    }

    /// Set a column projection by name.
    pub fn with_projection<I, S>(mut self, columns: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: Into<String>,
    {
        self.projection = Some(columns.into_iter().map(Into::into).collect());
        self
    }

    /// Set a predicate to apply.
    pub fn with_predicate(mut self, predicate: Expr) -> Self {
        self.predicate = Some(predicate);
        self
    }
}

/// Options for reading Parquet files.
#[derive(Debug, Clone)]
pub struct ParquetReadOptions {
    /// Optional column projection (names).
    pub columns: Option<Vec<String>>,
    /// Optional row group selection.
    pub row_groups: Option<Vec<usize>>,
    /// Record batch size for the Parquet reader.
    pub batch_size: usize,
    /// Optional predicate expression to apply (may be pushed down in the future).
    pub predicate: Option<Expr>,
}

impl Default for ParquetReadOptions {
    fn default() -> Self {
        Self {
            columns: None,
            row_groups: None,
            batch_size: 65_536,
            predicate: None,
        }
    }
}

impl ParquetReadOptions {
    /// Set a column projection by name.
    pub fn with_columns<I, S>(mut self, columns: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: Into<String>,
    {
        self.columns = Some(columns.into_iter().map(Into::into).collect());
        self
    }

    /// Set row group indices to read.
    pub fn with_row_groups<I>(mut self, row_groups: I) -> Self
    where
        I: IntoIterator<Item = usize>,
    {
        self.row_groups = Some(row_groups.into_iter().collect());
        self
    }

    /// Set record batch size.
    pub fn with_batch_size(mut self, batch_size: usize) -> Self {
        self.batch_size = batch_size;
        self
    }

    /// Set a predicate to apply.
    pub fn with_predicate(mut self, predicate: Expr) -> Self {
        self.predicate = Some(predicate);
        self
    }
}