polars_core/chunked_array/builder/list/
binary.rs

1use super::*;
2
3pub struct ListStringChunkedBuilder {
4    builder: LargeListBinViewBuilder<str>,
5    field: Field,
6    fast_explode: bool,
7}
8
9impl ListStringChunkedBuilder {
10    pub fn new(name: PlSmallStr, capacity: usize, values_capacity: usize) -> Self {
11        let values = MutableBinaryViewArray::with_capacity(values_capacity);
12        let builder = LargeListBinViewBuilder::new_with_capacity(values, capacity);
13        let field = Field::new(name, DataType::List(Box::new(DataType::String)));
14
15        ListStringChunkedBuilder {
16            builder,
17            field,
18            fast_explode: true,
19        }
20    }
21
22    #[inline]
23    pub fn append_trusted_len_iter<'a, I: Iterator<Item = Option<&'a str>> + TrustedLen>(
24        &mut self,
25        iter: I,
26    ) {
27        if iter.size_hint().0 == 0 {
28            self.fast_explode = false;
29        }
30        // SAFETY:
31        // trusted len, trust the type system
32        self.builder.mut_values().extend_trusted_len(iter);
33        self.builder.try_push_valid().unwrap();
34    }
35
36    #[inline]
37    pub fn append_values_iter<'a, I: Iterator<Item = &'a str>>(&mut self, iter: I) {
38        if iter.size_hint().0 == 0 {
39            self.fast_explode = false;
40        }
41        self.builder.mut_values().extend_values(iter);
42        self.builder.try_push_valid().unwrap();
43    }
44
45    #[inline]
46    pub(crate) fn append(&mut self, ca: &StringChunked) {
47        if ca.is_empty() {
48            self.fast_explode = false;
49        }
50        for arr in ca.downcast_iter() {
51            if arr.null_count() == 0 {
52                self.builder
53                    .mut_values()
54                    .extend_values(arr.non_null_values_iter());
55            } else {
56                self.builder.mut_values().extend_trusted_len(arr.iter())
57            }
58        }
59        self.builder.try_push_valid().unwrap();
60    }
61}
62
63impl ListBuilderTrait for ListStringChunkedBuilder {
64    #[inline]
65    fn append_null(&mut self) {
66        self.fast_explode = false;
67        self.builder.push_null();
68    }
69
70    #[inline]
71    fn append_series(&mut self, s: &Series) -> PolarsResult<()> {
72        if s.is_empty() {
73            self.fast_explode = false;
74        }
75        let ca = s.str()?;
76        self.append(ca);
77        Ok(())
78    }
79
80    fn field(&self) -> &Field {
81        &self.field
82    }
83
84    fn inner_array(&mut self) -> ArrayRef {
85        self.builder.as_box()
86    }
87
88    fn fast_explode(&self) -> bool {
89        self.fast_explode
90    }
91}
92
93pub struct ListBinaryChunkedBuilder {
94    builder: LargeListBinViewBuilder<[u8]>,
95    field: Field,
96    fast_explode: bool,
97}
98
99impl ListBinaryChunkedBuilder {
100    pub fn new(name: PlSmallStr, capacity: usize, values_capacity: usize) -> Self {
101        let values = MutablePlBinary::with_capacity(values_capacity);
102        let builder = LargeListBinViewBuilder::new_with_capacity(values, capacity);
103        let field = Field::new(name, DataType::List(Box::new(DataType::Binary)));
104
105        ListBinaryChunkedBuilder {
106            builder,
107            field,
108            fast_explode: true,
109        }
110    }
111
112    pub fn append_trusted_len_iter<'a, I: Iterator<Item = Option<&'a [u8]>> + TrustedLen>(
113        &mut self,
114        iter: I,
115    ) {
116        if iter.size_hint().0 == 0 {
117            self.fast_explode = false;
118        }
119        // SAFETY:
120        // trusted len, trust the type system
121        self.builder.mut_values().extend_trusted_len(iter);
122        self.builder.try_push_valid().unwrap();
123    }
124
125    pub fn append_values_iter<'a, I: Iterator<Item = &'a [u8]>>(&mut self, iter: I) {
126        if iter.size_hint().0 == 0 {
127            self.fast_explode = false;
128        }
129        self.builder.mut_values().extend_values(iter);
130        self.builder.try_push_valid().unwrap();
131    }
132
133    pub(crate) fn append(&mut self, ca: &BinaryChunked) {
134        if ca.is_empty() {
135            self.fast_explode = false;
136        }
137        for arr in ca.downcast_iter() {
138            if arr.null_count() == 0 {
139                self.builder
140                    .mut_values()
141                    .extend_values(arr.non_null_values_iter());
142            } else {
143                self.builder.mut_values().extend_trusted_len(arr.iter())
144            }
145        }
146        self.builder.try_push_valid().unwrap();
147    }
148}
149
150impl ListBuilderTrait for ListBinaryChunkedBuilder {
151    #[inline]
152    fn append_null(&mut self) {
153        self.fast_explode = false;
154        self.builder.push_null();
155    }
156
157    fn append_series(&mut self, s: &Series) -> PolarsResult<()> {
158        if s.is_empty() {
159            self.fast_explode = false;
160        }
161        let ca = s.binary()?;
162        self.append(ca);
163        Ok(())
164    }
165
166    fn field(&self) -> &Field {
167        &self.field
168    }
169
170    fn inner_array(&mut self) -> ArrayRef {
171        self.builder.as_box()
172    }
173
174    fn fast_explode(&self) -> bool {
175        self.fast_explode
176    }
177}
polars_core/chunked_array/builder/list/binary.rs

polars_core/chunked_array/builder/list/
binary.rs
