polars_core/chunked_array/builder/list/
mod.rs

1mod anonymous;
2mod binary;
3mod boolean;
4mod null;
5mod primitive;
6
7pub use anonymous::*;
8use arrow::legacy::array::list::AnonymousBuilder;
9use arrow::legacy::array::null::MutableNullArray;
10pub use binary::*;
11pub use boolean::*;
12pub use null::*;
13pub use primitive::*;
14
15use super::*;
16#[cfg(feature = "object")]
17use crate::chunked_array::object::registry::get_object_builder;
18
19pub trait ListBuilderTrait {
20    fn append_opt_series(&mut self, opt_s: Option<&Series>) -> PolarsResult<()> {
21        match opt_s {
22            Some(s) => return self.append_series(s),
23            None => self.append_null(),
24        }
25        Ok(())
26    }
27    fn append_series(&mut self, s: &Series) -> PolarsResult<()>;
28    fn append_null(&mut self);
29
30    fn field(&self) -> &Field {
31        unimplemented!()
32    }
33
34    fn inner_array(&mut self) -> ArrayRef {
35        unimplemented!()
36    }
37
38    fn fast_explode(&self) -> bool {
39        unimplemented!()
40    }
41
42    fn finish(&mut self) -> ListChunked {
43        let arr = self.inner_array();
44
45        let mut ca = ListChunked::new_with_compute_len(Arc::new(self.field().clone()), vec![arr]);
46        if self.fast_explode() {
47            ca.set_fast_explode()
48        }
49        ca
50    }
51}
52
53impl<S: ?Sized> ListBuilderTrait for Box<S>
54where
55    S: ListBuilderTrait,
56{
57    fn append_opt_series(&mut self, opt_s: Option<&Series>) -> PolarsResult<()> {
58        (**self).append_opt_series(opt_s)
59    }
60
61    fn append_series(&mut self, s: &Series) -> PolarsResult<()> {
62        (**self).append_series(s)
63    }
64
65    fn append_null(&mut self) {
66        (**self).append_null()
67    }
68
69    fn finish(&mut self) -> ListChunked {
70        (**self).finish()
71    }
72}
73
74type LargePrimitiveBuilder<T> = MutableListArray<i64, MutablePrimitiveArray<T>>;
75type LargeListBinViewBuilder<T> = MutableListArray<i64, MutableBinaryViewArray<T>>;
76type LargeListBooleanBuilder = MutableListArray<i64, MutableBooleanArray>;
77type LargeListNullBuilder = MutableListArray<i64, MutableNullArray>;
78
79pub fn get_list_builder(
80    inner_type_logical: &DataType,
81    value_capacity: usize,
82    list_capacity: usize,
83    name: PlSmallStr,
84) -> Box<dyn ListBuilderTrait> {
85    let physical_type = inner_type_logical.to_physical();
86
87    match &physical_type {
88        #[cfg(feature = "object")]
89        DataType::Object(_) => {
90            let builder = get_object_builder(PlSmallStr::EMPTY, 0).get_list_builder(
91                name,
92                value_capacity,
93                list_capacity,
94            );
95            Box::new(builder)
96        },
97        #[cfg(feature = "dtype-struct")]
98        DataType::Struct(_) => Box::new(AnonymousOwnedListBuilder::new(
99            name,
100            list_capacity,
101            Some(inner_type_logical.clone()),
102        )),
103        DataType::Null => Box::new(ListNullChunkedBuilder::new(name, list_capacity)),
104        DataType::List(_) => Box::new(AnonymousOwnedListBuilder::new(
105            name,
106            list_capacity,
107            Some(inner_type_logical.clone()),
108        )),
109        #[cfg(feature = "dtype-array")]
110        DataType::Array(..) => Box::new(AnonymousOwnedListBuilder::new(
111            name,
112            list_capacity,
113            Some(inner_type_logical.clone()),
114        )),
115        #[cfg(feature = "dtype-decimal")]
116        DataType::Decimal(_, _) => Box::new(
117            ListPrimitiveChunkedBuilder::<Int128Type>::new_with_values_type(
118                name,
119                list_capacity,
120                value_capacity,
121                physical_type,
122                inner_type_logical.clone(),
123            ),
124        ),
125        _ => {
126            macro_rules! get_primitive_builder {
127                ($type:ty) => {{
128                    let builder = ListPrimitiveChunkedBuilder::<$type>::new(
129                        name,
130                        list_capacity,
131                        value_capacity,
132                        inner_type_logical.clone(),
133                    );
134                    Box::new(builder)
135                }};
136            }
137            macro_rules! get_bool_builder {
138                () => {{
139                    let builder =
140                        ListBooleanChunkedBuilder::new(name, list_capacity, value_capacity);
141                    Box::new(builder)
142                }};
143            }
144            macro_rules! get_string_builder {
145                () => {{
146                    let builder =
147                        ListStringChunkedBuilder::new(name, list_capacity, 5 * value_capacity);
148                    Box::new(builder)
149                }};
150            }
151            macro_rules! get_binary_builder {
152                () => {{
153                    let builder =
154                        ListBinaryChunkedBuilder::new(name, list_capacity, 5 * value_capacity);
155                    Box::new(builder)
156                }};
157            }
158            match_dtype_to_logical_apply_macro!(
159                physical_type,
160                get_primitive_builder,
161                get_string_builder,
162                get_binary_builder,
163                get_bool_builder
164            )
165        },
166    }
167}
polars_core/chunked_array/builder/list/mod.rs

polars_core/chunked_array/builder/list/
mod.rs
