diff --git a/src/query/expression/src/aggregate/aggregate_hashtable.rs b/src/query/expression/src/aggregate/aggregate_hashtable.rs index 472d5745454ea..71563593d6909 100644 --- a/src/query/expression/src/aggregate/aggregate_hashtable.rs +++ b/src/query/expression/src/aggregate/aggregate_hashtable.rs @@ -20,7 +20,7 @@ use std::sync::Arc; use bumpalo::Bump; use databend_common_exception::Result; -use super::group_hash_columns; +use super::group_hash_entries; use super::hash_index::AdapterImpl; use super::hash_index::HashIndex; use super::partitioned_payload::PartitionedPayload; @@ -29,6 +29,7 @@ use super::probe_state::ProbeState; use super::Entry; use super::HashTableConfig; use super::Payload; +use super::BATCH_SIZE; use super::LOAD_FACTOR; use super::MAX_PAGE_SIZE; use crate::types::DataType; @@ -37,8 +38,6 @@ use crate::BlockEntry; use crate::ColumnBuilder; use crate::ProjectedBlock; -const BATCH_ADD_SIZE: usize = 2048; - pub struct AggregateHashTable { pub payload: PartitionedPayload, // use for append rows directly during deserialize @@ -129,12 +128,12 @@ impl AggregateHashTable { agg_states: ProjectedBlock, row_count: usize, ) -> Result { - if row_count <= BATCH_ADD_SIZE { + if row_count <= BATCH_SIZE { self.add_groups_inner(state, group_columns, params, agg_states, row_count) } else { let mut new_count = 0; - for start in (0..row_count).step_by(BATCH_ADD_SIZE) { - let end = (start + BATCH_ADD_SIZE).min(row_count); + for start in (0..row_count).step_by(BATCH_SIZE) { + let end = (start + BATCH_SIZE).min(row_count); let step_group_columns = group_columns .iter() .map(|entry| entry.slice(start..end)) @@ -188,11 +187,11 @@ impl AggregateHashTable { } state.row_count = row_count; - group_hash_columns(group_columns, &mut state.group_hashes); + group_hash_entries(group_columns, &mut state.group_hashes[..row_count]); let new_group_count = if self.direct_append { - for idx in 0..row_count { - state.empty_vector[idx] = idx; + for i in 0..row_count { + state.empty_vector[i] = i.into(); } self.payload.append_rows(state, row_count, group_columns); row_count @@ -232,7 +231,7 @@ impl AggregateHashTable { if self.config.partial_agg { // check size - if self.hash_index.count + BATCH_ADD_SIZE > self.hash_index.resize_threshold() + if self.hash_index.count + BATCH_SIZE > self.hash_index.resize_threshold() && self.hash_index.capacity >= self.config.max_partial_capacity { self.clear_ht(); diff --git a/src/query/expression/src/aggregate/group_hash.rs b/src/query/expression/src/aggregate/group_hash.rs index de2b6866758e7..3c93f7b65b6ac 100644 --- a/src/query/expression/src/aggregate/group_hash.rs +++ b/src/query/expression/src/aggregate/group_hash.rs @@ -19,38 +19,13 @@ use databend_common_column::types::Index; use databend_common_exception::ErrorCode; use databend_common_exception::Result; -use crate::types::i256; -use crate::types::number::Number; -use crate::types::AccessType; -use crate::types::AnyType; -use crate::types::BinaryColumn; -use crate::types::BinaryType; -use crate::types::BitmapType; -use crate::types::BooleanType; -use crate::types::DataType; -use crate::types::DateType; -use crate::types::DecimalColumn; -use crate::types::DecimalDataKind; -use crate::types::DecimalScalar; -use crate::types::DecimalView; -use crate::types::GeographyColumn; -use crate::types::GeographyType; -use crate::types::GeometryType; -use crate::types::NullableColumn; -use crate::types::NumberColumn; -use crate::types::NumberDataType; -use crate::types::NumberScalar; -use crate::types::NumberType; -use crate::types::OpaqueScalarRef; -use crate::types::StringColumn; -use crate::types::StringType; -use crate::types::TimestampType; -use crate::types::ValueType; -use crate::types::VariantType; +use crate::types::decimal::Decimal; +use crate::types::*; use crate::visitor::ValueVisitor; use crate::with_decimal_mapped_type; use crate::with_number_mapped_type; use crate::with_number_type; +use crate::BlockEntry; use crate::Column; use crate::ProjectedBlock; use crate::Scalar; @@ -59,23 +34,101 @@ use crate::Value; const NULL_HASH_VAL: u64 = 0xd1cefa08eb382d69; -pub fn group_hash_columns(cols: ProjectedBlock, values: &mut [u64]) { - debug_assert!(!cols.is_empty()); - for (i, entry) in cols.iter().enumerate() { - if i == 0 { - combine_group_hash_column::(&entry.to_column(), values); - } else { - combine_group_hash_column::(&entry.to_column(), values); +pub fn group_hash_entries(entries: ProjectedBlock, values: &mut [u64]) { + debug_assert!(!entries.is_empty()); + for (i, entry) in entries.iter().enumerate() { + debug_assert_eq!(entry.len(), values.len()); + match entry { + BlockEntry::Const(scalar, data_type, _) => { + if i == 0 { + combine_group_hash_const::(scalar, data_type, values); + } else { + combine_group_hash_const::(scalar, data_type, values); + } + } + BlockEntry::Column(column) => { + if i == 0 { + combine_group_hash_column::(column, values); + } else { + combine_group_hash_column::(column, values); + } + } } } } -pub fn combine_group_hash_column(c: &Column, values: &mut [u64]) { +fn combine_group_hash_column(c: &Column, values: &mut [u64]) { HashVisitor:: { values } .visit_column(c.clone()) .unwrap() } +fn combine_group_hash_const( + scalar: &Scalar, + data_type: &DataType, + values: &mut [u64], +) { + match data_type { + DataType::Null | DataType::EmptyArray | DataType::EmptyMap => {} + DataType::Nullable(inner) => { + if scalar.is_null() { + apply_const_hash::(values, NULL_HASH_VAL); + } else { + combine_group_hash_const_nonnull::(scalar, inner, values); + } + } + _ => combine_group_hash_const_nonnull::(scalar, data_type, values), + } +} + +fn combine_group_hash_const_nonnull( + scalar: &Scalar, + _data_type: &DataType, + values: &mut [u64], +) { + let hash = match scalar { + Scalar::Null => unreachable!(), + Scalar::EmptyArray | Scalar::EmptyMap => return, + Scalar::Number(v) => with_number_type!(|NUM_TYPE| match v { + NumberScalar::NUM_TYPE(value) => value.agg_hash(), + }), + Scalar::Decimal(v) => { + with_decimal_mapped_type!(|F| match v { + DecimalScalar::F(v, size) => { + with_decimal_mapped_type!(|T| match size.data_kind() { + DecimalDataKind::T => { + v.as_decimal::().agg_hash() + } + }) + } + }) + } + Scalar::Timestamp(value) => value.agg_hash(), + Scalar::Date(value) => value.agg_hash(), + Scalar::Boolean(value) => value.agg_hash(), + Scalar::String(value) => value.as_bytes().agg_hash(), + Scalar::Binary(value) + | Scalar::Bitmap(value) + | Scalar::Variant(value) + | Scalar::Geometry(value) => value.agg_hash(), + Scalar::Geography(value) => value.0.agg_hash(), + _ => scalar.as_ref().agg_hash(), + }; + apply_const_hash::(values, hash); +} + +fn apply_const_hash(values: &mut [u64], hash: u64) { + if IS_FIRST { + for val in values.iter_mut() { + *val = hash; + } + } else { + for val in values.iter_mut() { + *val = merge_hash(*val, hash); + } + } +} + struct HashVisitor<'a, const IS_FIRST: bool> { values: &'a mut [u64], } @@ -101,7 +154,7 @@ impl ValueVisitor for HashVisitor<'_, IS_FIRST> { fn visit_any_number(&mut self, column: NumberColumn) -> Result<()> { with_number_mapped_type!(|NUM_TYPE| match column.data_type() { NumberDataType::NUM_TYPE => { - let c = NUM_TYPE::try_downcast_column(&column).unwrap(); + let c = ::try_downcast_column(&column).unwrap(); self.combine_group_hash_type_column::>(&c) } }); @@ -573,22 +626,138 @@ impl AggHash for ScalarRef<'_> { #[cfg(test)] mod tests { use databend_common_column::bitmap::Bitmap; + use databend_common_column::types::months_days_micros; + use databend_common_column::types::timestamp_tz; use super::*; + use crate::types::geography::Geography; use crate::types::ArgType; - use crate::types::Int32Type; + use crate::types::DecimalSize; use crate::types::NullableColumn; - use crate::types::NullableType; - use crate::types::StringType; + use crate::types::NumberScalar; + use crate::types::OpaqueScalar; + use crate::types::VectorDataType; + use crate::types::VectorScalar; use crate::BlockEntry; use crate::DataBlock; use crate::FromData; + use crate::ProjectedBlock; use crate::Value; fn merge_hash_slice(ls: &[u64]) -> u64 { ls.iter().cloned().reduce(merge_hash).unwrap() } + #[test] + fn test_group_hash_entries_const_equals_column() { + let num_rows = 5; + let block = sample_block(num_rows); + let full_block = block.convert_to_full(); + + for projection in (0..block.num_columns()) + .map_windows(|[a, b]| vec![*a, *b]) + .chain(Some((0..block.num_columns()).collect())) + .collect::>() + { + let mut const_hashes = vec![0; block.num_rows()]; + let mut col_hashes = vec![0; full_block.num_rows()]; + group_hash_entries( + ProjectedBlock::project(&projection, &block), + &mut const_hashes, + ); + group_hash_entries( + ProjectedBlock::project(&projection, &full_block), + &mut col_hashes, + ); + assert_eq!(const_hashes, col_hashes); + } + } + + fn sample_block(num_rows: usize) -> DataBlock { + let cases = [ + (DataType::Null, Scalar::Null), + (DataType::EmptyArray, Scalar::EmptyArray), + (DataType::EmptyMap, Scalar::EmptyMap), + (DataType::Boolean, Scalar::Boolean(true)), + (DataType::Binary, Scalar::Binary(vec![1, 2, 3, 4])), + (DataType::String, Scalar::String("const_str".to_string())), + ( + Int32Type::data_type(), + Scalar::Number(NumberScalar::Int32(123)), + ), + ( + DataType::Number(NumberDataType::Float64), + Scalar::Number(NumberScalar::Float64(OrderedFloat(1.25))), + ), + { + let decimal_size = DecimalSize::new(20, 3).unwrap(); + ( + DataType::Decimal(decimal_size), + Scalar::Decimal(DecimalScalar::Decimal128(123456_i128, decimal_size)), + ) + }, + (DataType::Timestamp, Scalar::Timestamp(123_456_789)), + ( + DataType::TimestampTz, + Scalar::TimestampTz(timestamp_tz::new(123_456, 3_600)), + ), + (DataType::Date, Scalar::Date(42)), + ( + DataType::Interval, + Scalar::Interval(months_days_micros::new(1, 2, 3)), + ), + (DataType::Bitmap, Scalar::Bitmap(vec![0b10101010])), + (DataType::Variant, Scalar::Variant(vec![1, 2, 3, 4])), + (DataType::Geometry, Scalar::Geometry(vec![9, 9, 9])), + ( + DataType::Geography, + Scalar::Geography(Geography(vec![1, 2, 3])), + ), + ( + DataType::Vector(VectorDataType::Int8(2)), + Scalar::Vector(VectorScalar::Int8(vec![1, 2])), + ), + ( + DataType::Opaque(2), + Scalar::Opaque(OpaqueScalar::Opaque2([1, 2])), + ), + { + let array_ty = DataType::Array(Box::new(Int32Type::data_type())); + (array_ty.clone(), Scalar::default_value(&array_ty)) + }, + { + let map_ty = DataType::Map(Box::new(DataType::Tuple(vec![ + DataType::String, + Int32Type::data_type(), + ]))); + let val = Scalar::default_value(&map_ty); + (map_ty, val) + }, + { + let tuple_ty = DataType::Tuple(vec![DataType::String, Int32Type::data_type()]); + ( + tuple_ty, + Scalar::Tuple(vec![ + Scalar::String("tuple_0".to_string()), + Scalar::Number(NumberScalar::Int32(0)), + ]), + ) + }, + ( + Int32Type::data_type().wrap_nullable(), + Scalar::Number(NumberScalar::Int32(999)), + ), + (Int32Type::data_type().wrap_nullable(), Scalar::Null), + ]; + + DataBlock::from_iter( + cases.into_iter().map(|(data_type, scalar)| { + BlockEntry::new_const_column(data_type, scalar, num_rows) + }), + num_rows, + ) + } + #[test] fn test_value_spread() -> Result<()> { let data = DataBlock::new( diff --git a/src/query/expression/src/aggregate/hash_index.rs b/src/query/expression/src/aggregate/hash_index.rs index e8d2516341339..95de04d0f7932 100644 --- a/src/query/expression/src/aggregate/hash_index.rs +++ b/src/query/expression/src/aggregate/hash_index.rs @@ -12,6 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. +use std::fmt::Debug; + +use super::payload_row::CompareState; use super::PartitionedPayload; use super::ProbeState; use super::RowPtr; @@ -114,7 +117,7 @@ const SALT_MASK: u64 = 0xFFFF000000000000; const POINTER_MASK: u64 = 0x0000FFFFFFFFFFFF; // The high 16 bits are the salt, the low 48 bits are the pointer address -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +#[derive(Clone, Copy, PartialEq, Eq, Default)] pub(super) struct Entry(pub(super) u64); impl Entry { @@ -153,6 +156,15 @@ impl Entry { } } +impl Debug for Entry { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_tuple("Entry") + .field(&self.get_salt()) + .field(&self.get_pointer()) + .finish() + } +} + pub(super) trait TableAdapter { fn append_rows(&mut self, state: &mut ProbeState, new_entry_count: usize); @@ -172,17 +184,10 @@ impl HashIndex { mut adapter: impl TableAdapter, ) -> usize { for (i, row) in state.no_match_vector[..row_count].iter_mut().enumerate() { - *row = i; + *row = i.into(); + state.slots[i] = init_slot(state.group_hashes[i], self.capacity_mask); } - let mut slots = state.get_temp(); - slots.extend( - state.group_hashes[..row_count] - .iter() - .map(|hash| init_slot(*hash, self.capacity_mask)), - ); - let capacity_mask = self.capacity_mask; - let mut new_group_count = 0; let mut remaining_entries = row_count; @@ -193,12 +198,10 @@ impl HashIndex { // 1. inject new_group_count, new_entry_count, need_compare_count, no_match_count for row in state.no_match_vector[..remaining_entries].iter().copied() { - let slot = &mut slots[row]; - let hash = state.group_hashes[row]; - + let slot = &mut state.slots[row]; let is_new; - (*slot, is_new) = self.find_or_insert(*slot, hash); + (*slot, is_new) = self.find_or_insert(*slot, state.group_hashes[row]); if is_new { state.empty_vector[new_entry_count] = row; new_entry_count += 1; @@ -215,7 +218,7 @@ impl HashIndex { adapter.append_rows(state, new_entry_count); for row in state.empty_vector[..new_entry_count].iter().copied() { - let entry = self.mut_entry(slots[row]); + let entry = self.mut_entry(state.slots[row]); entry.set_pointer(state.addresses[row]); debug_assert_eq!(entry.get_pointer(), state.addresses[row]); } @@ -227,7 +230,7 @@ impl HashIndex { .iter() .copied() { - let entry = self.mut_entry(slots[row]); + let entry = self.mut_entry(state.slots[row]); debug_assert!(entry.is_occupied()); debug_assert_eq!(entry.get_salt(), (state.group_hashes[row] >> 48) as u16); @@ -240,14 +243,13 @@ impl HashIndex { // 5. Linear probing with hash-derived step for row in state.no_match_vector[..no_match_count].iter().copied() { - let slot = &mut slots[row]; + let slot = &mut state.slots[row]; let hash = state.group_hashes[row]; - *slot = next_slot(*slot, hash, capacity_mask); + *slot = next_slot(*slot, hash, self.capacity_mask); } remaining_entries = no_match_count; } - state.save_temp(slots); self.count += new_group_count; new_group_count @@ -270,7 +272,13 @@ impl<'a> TableAdapter for AdapterImpl<'a> { need_compare_count: usize, no_match_count: usize, ) -> usize { - state.row_match_columns( + // todo: compare hash first if NECESSARY + CompareState { + address: &state.addresses, + compare: &mut state.group_compare_vector, + no_matched: &mut state.no_match_vector, + } + .row_match_entries( self.group_columns, &self.payload.row_layout, (need_compare_count, no_match_count), @@ -304,8 +312,10 @@ mod tests { } fn init_state(&self) -> ProbeState { - let mut state = ProbeState::default(); - state.row_count = self.incoming.len(); + let mut state = ProbeState { + row_count: self.incoming.len(), + ..Default::default() + }; for (i, (_, hash)) in self.incoming.iter().enumerate() { state.group_hashes[i] = *hash @@ -343,12 +353,12 @@ mod tests { impl TableAdapter for &mut TestTableAdapter { fn append_rows(&mut self, state: &mut ProbeState, new_entry_count: usize) { - for row in state.empty_vector[..new_entry_count].iter().copied() { - let (key, hash) = self.incoming[row]; + for row in state.empty_vector[..new_entry_count].iter() { + let (key, hash) = self.incoming[*row]; let value = key + 20; self.payload.push((key, hash, value)); - state.addresses[row] = self.get_row_ptr(true, row); + state.addresses[*row] = self.get_row_ptr(true, row.to_usize()); } } @@ -364,9 +374,7 @@ mod tests { { let incoming = self.incoming[row]; - let row_ptr = state.addresses[row]; - - let (key, hash, _) = self.get_payload(row_ptr); + let (key, hash, _) = self.get_payload(state.addresses[row]); const POINTER_MASK: u64 = 0x0000FFFFFFFFFFFF; assert_eq!(incoming.1 | POINTER_MASK, hash | POINTER_MASK); diff --git a/src/query/expression/src/aggregate/mod.rs b/src/query/expression/src/aggregate/mod.rs index 5ad420bdd0a87..f19400517329b 100644 --- a/src/query/expression/src/aggregate/mod.rs +++ b/src/query/expression/src/aggregate/mod.rs @@ -39,8 +39,9 @@ use hash_index::Entry; pub use partitioned_payload::*; pub use payload::*; pub use payload_flush::*; -pub use probe_state::*; -use row_ptr::RowPtr; +pub use probe_state::ProbeState; +use probe_state::*; +use row_ptr::*; // A batch size to probe, flush, repartition, etc. pub(crate) const BATCH_SIZE: usize = 2048; diff --git a/src/query/expression/src/aggregate/partitioned_payload.rs b/src/query/expression/src/aggregate/partitioned_payload.rs index d17deeb9721d5..8f3c7689db41c 100644 --- a/src/query/expression/src/aggregate/partitioned_payload.rs +++ b/src/query/expression/src/aggregate/partitioned_payload.rs @@ -28,6 +28,28 @@ use crate::ProjectedBlock; use crate::StatesLayout; use crate::BATCH_SIZE; +#[derive(Debug, Clone, Copy)] +struct PartitionMask { + mask: u64, + shift: u64, +} + +impl PartitionMask { + fn new(partition_count: u64) -> Self { + let radix_bits = partition_count.trailing_zeros() as u64; + debug_assert_eq!(1 << radix_bits, partition_count); + + let shift = 48 - radix_bits; + let mask = ((1 << radix_bits) - 1) << shift; + + Self { mask, shift } + } + + pub fn index(&self, hash: u64) -> usize { + ((hash & self.mask) >> self.shift) as _ + } +} + pub struct PartitionedPayload { pub payloads: Vec, pub group_types: Vec, @@ -37,9 +59,7 @@ pub struct PartitionedPayload { pub arenas: Vec>, - partition_count: u64, - mask_v: u64, - shift_v: u64, + partition_mask: PartitionMask, } unsafe impl Send for PartitionedPayload {} @@ -52,9 +72,6 @@ impl PartitionedPayload { partition_count: u64, arenas: Vec>, ) -> Self { - let radix_bits = partition_count.trailing_zeros() as u64; - debug_assert_eq!(1 << radix_bits, partition_count); - let states_layout = if !aggrs.is_empty() { Some(get_states_layout(&aggrs).unwrap()) } else { @@ -72,7 +89,7 @@ impl PartitionedPayload { }) .collect_vec(); - let offsets = RowLayout { + let row_layout = RowLayout { states_layout, ..payloads[0].row_layout.clone() }; @@ -81,12 +98,10 @@ impl PartitionedPayload { payloads, group_types, aggrs, - row_layout: offsets, - partition_count, + row_layout, arenas, - mask_v: mask(radix_bits), - shift_v: shift(radix_bits), + partition_mask: PartitionMask::new(partition_count), } } @@ -119,10 +134,10 @@ impl PartitionedPayload { state.reset_partitions(self.partition_count()); for &row in &state.empty_vector[..new_group_rows] { let hash = state.group_hashes[row]; - let partition_idx = ((hash & self.mask_v) >> self.shift_v) as usize; + let partition_idx = self.partition_mask.index(hash); let (count, sel) = &mut state.partition_entries[partition_idx]; - sel[*count] = row; + sel[*count as usize] = row; *count += 1; } @@ -133,7 +148,7 @@ impl PartitionedPayload { { if *count > 0 { payload.reserve_append_rows( - &sel[..*count], + &sel[..*count as _], &state.group_hashes, &mut state.addresses, &mut state.page_index, @@ -149,19 +164,27 @@ impl PartitionedPayload { return self; } - let mut new_partition_payload = PartitionedPayload::new( - self.group_types.clone(), - self.aggrs.clone(), - new_partition_count as u64, - self.arenas.clone(), - ); + let PartitionedPayload { + payloads, + group_types, + aggrs, + arenas, + .. + } = self; + + let mut new_partition_payload = + PartitionedPayload::new(group_types, aggrs, new_partition_count as u64, arenas); + + state.clear(); + for payload in payloads.into_iter() { + new_partition_payload.combine_single(payload, state, None) + } - new_partition_payload.combine(self, state); new_partition_payload } pub fn combine(&mut self, other: PartitionedPayload, state: &mut PayloadFlushState) { - if other.partition_count == self.partition_count { + if other.partition_count() == self.partition_count() { for (l, r) in self.payloads.iter_mut().zip(other.payloads.into_iter()) { l.combine(r); } @@ -184,7 +207,7 @@ impl PartitionedPayload { return; } - if self.partition_count == 1 { + if self.partition_count() == 1 { self.payloads[0].combine(other); } else { flush_state.clear(); @@ -194,13 +217,19 @@ impl PartitionedPayload { // copy rows let state = &*flush_state.probe_state; - for partition in (0..self.partition_count as usize) - .filter(|x| only_bucket.is_none() || only_bucket == Some(*x)) - { - let (count, sel) = &state.partition_entries[partition]; - if *count > 0 { - let payload = &mut self.payloads[partition]; - payload.copy_rows(&sel[..*count], &flush_state.addresses); + match only_bucket { + Some(i) => { + let (count, sel) = &state.partition_entries[i]; + self.payloads[i].copy_rows(&sel[..*count as _], &flush_state.addresses); + } + None => { + for ((count, sel), payload) in + state.partition_entries.iter().zip(self.payloads.iter_mut()) + { + if *count > 0 { + payload.copy_rows(&sel[..*count as _], &flush_state.addresses); + } + } } } } @@ -236,10 +265,10 @@ impl PartitionedPayload { flush_state.addresses[idx] = row_ptr; let hash = row_ptr.hash(&self.row_layout); - let partition_idx = ((hash & self.mask_v) >> self.shift_v) as usize; + let partition_idx = self.partition_mask.index(hash); let (count, sel) = &mut state.partition_entries[partition_idx]; - sel[*count] = idx; + sel[*count as usize] = idx.into(); *count += 1; } flush_state.flush_page_row = end; @@ -253,7 +282,7 @@ impl PartitionedPayload { #[inline] pub fn partition_count(&self) -> usize { - self.partition_count as usize + self.payloads.len() } #[allow(dead_code)] @@ -266,13 +295,3 @@ impl PartitionedPayload { self.payloads.iter().map(|x| x.memory_size()).sum() } } - -#[inline] -fn shift(radix_bits: u64) -> u64 { - 48 - radix_bits -} - -#[inline] -fn mask(radix_bits: u64) -> u64 { - ((1 << radix_bits) - 1) << shift(radix_bits) -} diff --git a/src/query/expression/src/aggregate/payload.rs b/src/query/expression/src/aggregate/payload.rs index 9099e5dc008ee..42c6d92015b66 100644 --- a/src/query/expression/src/aggregate/payload.rs +++ b/src/query/expression/src/aggregate/payload.rs @@ -22,11 +22,14 @@ use strength_reduce::StrengthReducedU64; use super::payload_row::rowformat_size; use super::payload_row::serialize_column_to_rowformat; +use super::payload_row::serialize_const_column_to_rowformat; use super::row_ptr::RowLayout; use super::row_ptr::RowPtr; +use super::RowID; use crate::types::DataType; use crate::AggrState; use crate::AggregateFunctionRef; +use crate::BlockEntry; use crate::Column; use crate::ColumnBuilder; use crate::DataBlock; @@ -197,7 +200,7 @@ impl Payload { pub(super) fn reserve_append_rows( &mut self, - select_vector: &[usize], + select_vector: &[RowID], group_hashes: &[u64; BATCH_SIZE], address: &mut [RowPtr; BATCH_SIZE], page_index: &mut [usize], @@ -205,9 +208,9 @@ impl Payload { ) { let tuple_size = self.tuple_size; let (mut page, mut page_index_value) = self.writable_page(); - for idx in select_vector.iter().copied() { - address[idx] = page.data_ptr(page.rows, tuple_size); - page_index[idx] = page_index_value; + for row in select_vector { + address[*row] = page.data_ptr(page.rows, tuple_size); + page_index[*row] = page_index_value; page.rows += 1; if page.rows == page.capacity { @@ -226,7 +229,7 @@ impl Payload { fn append_rows( &mut self, - select_vector: &[usize], + select_vector: &[RowID], group_hashes: &[u64; BATCH_SIZE], address: &mut [RowPtr; BATCH_SIZE], page_index: &mut [usize], @@ -235,24 +238,37 @@ impl Payload { let mut write_offset = 0; // write validity for entry in group_columns.iter() { - if let Column::Nullable(c) = entry.to_column() { - let bitmap = c.validity(); - if bitmap.null_count() == 0 || bitmap.null_count() == bitmap.len() { - let val: u8 = if bitmap.null_count() == 0 { 1 } else { 0 }; - // faster path - for idx in select_vector.iter().copied() { + match entry { + BlockEntry::Const(scalar, DataType::Nullable(_), _) => { + let val = if scalar.is_null() { 0 } else { 1 }; + for row in select_vector { unsafe { - address[idx].write_u8(write_offset, val); + address[*row].write_u8(write_offset, val); } } - } else { - for idx in select_vector.iter().copied() { - unsafe { - address[idx].write_u8(write_offset, bitmap.get_bit(idx) as u8); + write_offset += 1; + } + BlockEntry::Column(Column::Nullable(box c)) => { + let bitmap = c.validity(); + if bitmap.null_count() == 0 || bitmap.null_count() == bitmap.len() { + let val: u8 = if bitmap.null_count() == 0 { 1 } else { 0 }; + // faster path + for row in select_vector { + unsafe { + address[*row].write_u8(write_offset, val); + } + } + } else { + for row in select_vector { + unsafe { + address[*row] + .write_u8(write_offset, bitmap.get_bit(row.to_usize()) as u8); + } } } + write_offset += 1; } - write_offset += 1; + _ => (), } } @@ -261,23 +277,37 @@ impl Payload { let offset = self.row_layout.group_offsets[idx]; assert!(write_offset == offset); - unsafe { - serialize_column_to_rowformat( - &self.arena, - &entry.to_column(), - select_vector, - address, - offset, - &mut scratch, - ); + match entry { + BlockEntry::Const(scalar, data_type, _) => unsafe { + serialize_const_column_to_rowformat( + &self.arena, + scalar, + data_type, + select_vector, + address, + offset, + &mut scratch, + ) + }, + BlockEntry::Column(column) => unsafe { + serialize_column_to_rowformat( + &self.arena, + column, + select_vector, + address, + offset, + &mut scratch, + ); + }, } + write_offset += self.row_layout.group_sizes[idx]; } // write group hashes debug_assert!(write_offset == self.row_layout.hash_offset); - for idx in select_vector.iter().copied() { - address[idx].set_hash(&self.row_layout, group_hashes[idx]); + for row in select_vector { + address[*row].set_hash(&self.row_layout, group_hashes[*row]); } debug_assert!(write_offset + 8 == self.row_layout.state_offset); @@ -289,15 +319,15 @@ impl Payload { let (array_layout, padded_size) = layout.repeat(select_vector.len()).unwrap(); // Bump only allocates but does not drop, so there is no use after free for any item. let place = self.arena.alloc_layout(array_layout); - for (idx, place) in select_vector + for (row, place) in select_vector .iter() .copied() .enumerate() - .map(|(i, idx)| (idx, unsafe { place.add(padded_size * i) })) + .map(|(i, row)| (row, unsafe { place.add(padded_size * i) })) { let place = StateAddr::from(place); - address[idx].set_state_addr(&self.row_layout, &place); - let page = &mut self.pages[page_index[idx]]; + address[row].set_state_addr(&self.row_layout, &place); + let page = &mut self.pages[page_index[row]]; for (aggr, loc) in self.aggrs.iter().zip(states_loc.iter()) { aggr.init_state(AggrState::new(place, loc)); page.state_offsets += 1; @@ -336,7 +366,7 @@ impl Payload { } } - pub fn copy_rows(&mut self, select_vector: &[usize], address: &[RowPtr; BATCH_SIZE]) { + pub fn copy_rows(&mut self, select_vector: &[RowID], address: &[RowPtr; BATCH_SIZE]) { let tuple_size = self.tuple_size; let agg_len = self.aggrs.len(); let (mut page, _) = self.writable_page(); @@ -395,7 +425,7 @@ impl Payload { let partition_idx = (hash % mods) as usize; let (count, sel) = &mut state.partition_entries[partition_idx]; - sel[*count] = idx; + sel[*count as usize] = idx.into(); *count += 1; } flush_state.flush_page_row = end; diff --git a/src/query/expression/src/aggregate/payload_flush.rs b/src/query/expression/src/aggregate/payload_flush.rs index 5e06922a1c991..d456a343c12f2 100644 --- a/src/query/expression/src/aggregate/payload_flush.rs +++ b/src/query/expression/src/aggregate/payload_flush.rs @@ -293,12 +293,7 @@ impl Payload { unsafe { for idx in 0..len { - let str_len = state.addresses[idx].read::(col_offset) as usize; - let data_address = - state.addresses[idx].read::(col_offset + 4) as usize as *const u8; - - let scalar = std::slice::from_raw_parts(data_address, str_len); - + let scalar = state.addresses[idx].read_bytes(col_offset); binary_builder.put_slice(scalar); binary_builder.commit_row(); } @@ -316,12 +311,7 @@ impl Payload { unsafe { for idx in 0..len { - let str_len = state.addresses[idx].read::(col_offset) as usize; - let data_address = - state.addresses[idx].read::(col_offset + 4) as usize as *const u8; - - let scalar = std::slice::from_raw_parts(data_address, str_len); - + let scalar = state.addresses[idx].read_bytes(col_offset); binary_builder.put_and_commit(std::str::from_utf8(scalar).unwrap()); } } diff --git a/src/query/expression/src/aggregate/payload_row.rs b/src/query/expression/src/aggregate/payload_row.rs index 4b3d916c03d91..7c00477de9b2d 100644 --- a/src/query/expression/src/aggregate/payload_row.rs +++ b/src/query/expression/src/aggregate/payload_row.rs @@ -13,13 +13,15 @@ // limitations under the License. use bumpalo::Bump; +use databend_common_base::hints::assume; use databend_common_column::bitmap::Bitmap; use databend_common_io::prelude::bincode_deserialize_from_slice; use databend_common_io::prelude::bincode_serialize_into_buf; -use super::probe_state::ProbeState; -use super::row_ptr::RowLayout; -use super::row_ptr::RowPtr; +use super::RowID; +use super::RowLayout; +use super::RowPtr; +use crate::types::decimal::Decimal; use crate::types::decimal::DecimalColumn; use crate::types::i256; use crate::types::AccessType; @@ -29,13 +31,15 @@ use crate::types::BooleanType; use crate::types::DataType; use crate::types::DateType; use crate::types::DecimalDataKind; +use crate::types::DecimalScalar; use crate::types::DecimalView; use crate::types::NumberColumn; +use crate::types::NumberScalar; use crate::types::NumberType; -use crate::types::StringType; use crate::types::TimestampType; use crate::with_decimal_mapped_type; use crate::with_number_mapped_type; +use crate::BlockEntry; use crate::Column; use crate::ProjectedBlock; use crate::Scalar; @@ -77,7 +81,7 @@ pub(super) fn rowformat_size(data_type: &DataType) -> usize { pub(super) unsafe fn serialize_column_to_rowformat( arena: &Bump, column: &Column, - select_vector: &[usize], + select_vector: &[RowID], address: &mut [RowPtr; BATCH_SIZE], offset: usize, scratch: &mut Vec, @@ -86,8 +90,8 @@ pub(super) unsafe fn serialize_column_to_rowformat( Column::Null { .. } | Column::EmptyArray { .. } | Column::EmptyMap { .. } => {} Column::Number(v) => with_number_mapped_type!(|NUM_TYPE| match v { NumberColumn::NUM_TYPE(buffer) => { - for &index in select_vector { - address[index].write(offset, &buffer[index]); + for row in select_vector { + address[*row].write(offset, &buffer[*row]); } } }), @@ -111,35 +115,35 @@ pub(super) unsafe fn serialize_column_to_rowformat( if v.null_count() == 0 || v.null_count() == v.len() { let val: u8 = if v.null_count() == 0 { 1 } else { 0 }; // faster path - for &index in select_vector { - address[index].write_u8(offset, val); + for row in select_vector { + address[*row].write_u8(offset, val); } } else { - for &index in select_vector { - address[index].write_u8(offset, v.get_bit(index) as u8); + for row in select_vector { + address[*row].write_u8(offset, v.get_bit(row.to_usize()) as u8); } } } Column::Binary(v) | Column::Bitmap(v) | Column::Variant(v) | Column::Geometry(v) => { - for &index in select_vector { - let data = arena.alloc_slice_copy(v.index_unchecked(index)); - address[index].write_bytes(offset, data); + for row in select_vector { + let data = arena.alloc_slice_copy(v.index_unchecked(row.to_usize())); + address[*row].write_bytes(offset, data); } } Column::String(v) => { - for &index in select_vector { - let data = arena.alloc_str(v.index_unchecked(index)); - address[index].write_bytes(offset, data.as_bytes()); + for row in select_vector { + let data = arena.alloc_str(v.index_unchecked(row.to_usize())); + address[*row].write_bytes(offset, data.as_bytes()); } } Column::Timestamp(buffer) => { - for &index in select_vector { - address[index].write(offset, &buffer[index]); + for row in select_vector { + address[*row].write(offset, &buffer[*row]); } } Column::Date(buffer) => { - for &index in select_vector { - address[index].write(offset, &buffer[index]); + for row in select_vector { + address[*row].write(offset, &buffer[*row]); } } Column::Nullable(c) => { @@ -148,13 +152,103 @@ pub(super) unsafe fn serialize_column_to_rowformat( // for complex column other => { - for &index in select_vector { - let s = other.index_unchecked(index).to_owned(); + for row in select_vector { + let s = other.index_unchecked(row.to_usize()).to_owned(); scratch.clear(); bincode_serialize_into_buf(scratch, &s).unwrap(); let data = arena.alloc_slice_copy(scratch); - address[index].write_bytes(offset, data); + address[*row].write_bytes(offset, data); + } + } + } +} + +pub(super) unsafe fn serialize_const_column_to_rowformat( + arena: &Bump, + scalar: &Scalar, + data_type: &DataType, + select_vector: &[RowID], + address: &mut [RowPtr; BATCH_SIZE], + offset: usize, + scratch: &mut Vec, +) { + match scalar { + Scalar::Null => { + if let Some(box data_type) = data_type.as_nullable() { + serialize_const_column_to_rowformat( + arena, + &Scalar::default_value(data_type), + data_type, + select_vector, + address, + offset, + scratch, + ) + } + } + Scalar::EmptyArray | Scalar::EmptyMap => (), + Scalar::Number(number_scalar) => with_number_mapped_type!(|NUM_TYPE| match number_scalar { + NumberScalar::NUM_TYPE(value) => { + for row in select_vector { + address[*row].write(offset, value); + } + } + }), + Scalar::Decimal(decimal_scalar) => { + let size = decimal_scalar.size(); + with_decimal_mapped_type!(|T| match size.data_kind() { + DecimalDataKind::T => { + let value: T = decimal_scalar.as_decimal(); + for row in select_vector { + address[*row].write(offset, &value); + } + } + }) + } + Scalar::Boolean(value) => { + let value = if *value { 1 } else { 0 }; + for row in select_vector { + address[*row].write_u8(offset, value); + } + } + Scalar::Timestamp(value) => { + for row in select_vector { + address[*row].write(offset, value); + } + } + Scalar::Date(value) => { + for row in select_vector { + address[*row].write(offset, value); + } + } + Scalar::Interval(value) => { + for row in select_vector { + address[*row].write(offset, value); + } + } + Scalar::String(value) => { + let data = arena.alloc_str(value); + let bytes = data.as_bytes(); + for row in select_vector { + address[*row].write_bytes(offset, bytes); + } + } + Scalar::Binary(value) + | Scalar::Bitmap(value) + | Scalar::Variant(value) + | Scalar::Geometry(value) => { + let data = arena.alloc_slice_copy(value); + for row in select_vector { + address[*row].write_bytes(offset, data); + } + } + other => { + scratch.clear(); + bincode_serialize_into_buf(scratch, other).unwrap(); + let data = arena.alloc_slice_copy(scratch); + for row in select_vector { + address[*row].write_bytes(offset, data); } } } @@ -162,34 +256,47 @@ pub(super) unsafe fn serialize_column_to_rowformat( unsafe fn serialize_fixed_size_column_to_rowformat( column: &T::Column, - select_vector: &[usize], + select_vector: &[RowID], address: &mut [RowPtr; BATCH_SIZE], offset: usize, ) where T: AccessType, { - for index in select_vector.iter().copied() { - let val = T::index_column_unchecked_scalar(column, index); - address[index].write(offset, &val); + for row in select_vector { + let val = T::index_column_unchecked_scalar(column, row.to_usize()); + address[*row].write(offset, &val); } } -impl ProbeState { - pub(super) fn row_match_columns( - &mut self, - cols: ProjectedBlock, +pub struct CompareState<'a> { + pub(super) address: &'a [RowPtr; BATCH_SIZE], + pub(super) compare: &'a mut [RowID; BATCH_SIZE], + pub(super) no_matched: &'a mut [RowID; BATCH_SIZE], +} + +impl<'s> CompareState<'s> { + pub(super) fn row_match_entries( + mut self, + entries: ProjectedBlock, row_layout: &RowLayout, (mut count, mut no_match_count): (usize, usize), ) -> usize { - for ((entry, col_offset), validity_offset) in cols + for ((entry, col_offset), validity_offset) in entries .iter() .zip(row_layout.group_offsets.iter()) .zip(row_layout.validity_offsets.iter()) { - (count, no_match_count) = self.row_match_column( - &entry.to_column(), - *validity_offset, + if matches!( + entry.data_type(), + DataType::Null | DataType::EmptyMap | DataType::EmptyArray + ) { + continue; + } + + (count, no_match_count) = self.match_entry( + entry, *col_offset, + *validity_offset, (count, no_match_count), ); @@ -201,198 +308,245 @@ impl ProbeState { no_match_count } - fn row_match_column( + fn match_entry( &mut self, - col: &Column, - validity_offset: usize, + entry: &BlockEntry, col_offset: usize, - (count, no_match_count): (usize, usize), + validity_offset: usize, + counts: (usize, usize), ) -> (usize, usize) { - let (validity, col) = if let Column::Nullable(c) = col { - (Some(&c.validity), &c.column) - } else { - (None, col) - }; + match entry { + BlockEntry::Const(scalar, DataType::Nullable(_), _) => { + if scalar.is_null() { + self.match_with(counts, |_, row_ptr| unsafe { + !row_ptr.read_bool(validity_offset) + }) + } else { + let counts = self.match_with(counts, |_, row_ptr| unsafe { + row_ptr.read_bool(validity_offset) + }); + self.match_const_column(scalar, col_offset, counts) + } + } + BlockEntry::Const(scalar, _, _) => self.match_const_column(scalar, col_offset, counts), + BlockEntry::Column(column) => match column { + Column::Nullable(c) => { + if c.validity.null_count() == 0 { + let counts = self.match_with(counts, |_, row_ptr| unsafe { + row_ptr.read_bool(validity_offset) + }); + self.match_column(&c.column, col_offset, None, counts) + } else if c.validity.true_count() == 0 { + self.match_with(counts, |_, row_ptr| unsafe { + !row_ptr.read_bool(validity_offset) + }) + } else { + self.match_column( + &c.column, + col_offset, + Some((&c.validity, validity_offset)), + counts, + ) + } + } + column => self.match_column(column, col_offset, None, counts), + }, + } + } + fn match_column( + &mut self, + col: &Column, + col_offset: usize, + validity: Option<(&Bitmap, usize)>, + counts: (usize, usize), + ) -> (usize, usize) { match col { - Column::Null { .. } | Column::EmptyArray { .. } | Column::EmptyMap { .. } => { - (no_match_count, no_match_count) + Column::EmptyArray { .. } | Column::EmptyMap { .. } => { + self.match_validity_with(counts, validity, |_, _| true) } - Column::Number(v) => with_number_mapped_type!(|NUM_TYPE| match v { - NumberColumn::NUM_TYPE(_) => { - self.row_match_column_type::>( - col, - validity, - validity_offset, - col_offset, - (count, no_match_count), + NumberColumn::NUM_TYPE(buffer) => { + self.match_column_type::>( + buffer, col_offset, validity, counts, ) } }), Column::Decimal(decimal_column) => { with_decimal_mapped_type!(|F| match decimal_column { - DecimalColumn::F(_, size) => { + DecimalColumn::F(buffer, size) => { with_decimal_mapped_type!(|T| match size.data_kind() { DecimalDataKind::T => { - self.row_match_column_type::>( - col, - validity, - validity_offset, - col_offset, - (count, no_match_count), + self.match_column_type::>( + buffer, col_offset, validity, counts, ) } }) } }) } - Column::Boolean(_) => self.row_match_column_type::( - col, - validity, - validity_offset, - col_offset, - (count, no_match_count), - ), - Column::Timestamp(_) => self.row_match_column_type::( - col, - validity, - validity_offset, - col_offset, - (count, no_match_count), - ), - Column::Date(_) => self.row_match_column_type::( - col, - validity, - validity_offset, - col_offset, - (count, no_match_count), - ), - Column::String(v) => self.row_match_column_generic( - validity, - validity_offset, - (count, no_match_count), - |idx, row_ptr| unsafe { - let value = StringType::index_column_unchecked(v, idx); - row_ptr.is_bytes_eq(col_offset, value.as_bytes()) - }, - ), + Column::Boolean(v) => { + self.match_column_type::(v, col_offset, validity, counts) + } + Column::Timestamp(buffer) => { + self.match_column_type::(buffer, col_offset, validity, counts) + } + Column::Date(buffer) => { + self.match_column_type::(buffer, col_offset, validity, counts) + } + Column::String(str_view) => { + self.match_validity_with(counts, validity, |row, row_ptr| unsafe { + row_ptr.eq_string_view(col_offset, str_view, *row) + }) + } Column::Bitmap(v) | Column::Binary(v) | Column::Variant(v) | Column::Geometry(v) => { - self.row_match_column_generic( - validity, - validity_offset, - (count, no_match_count), - |idx, row_ptr| unsafe { - let value = BinaryType::index_column_unchecked(v, idx); - row_ptr.is_bytes_eq(col_offset, value) - }, - ) + self.match_validity_with(counts, validity, |row, row_ptr| unsafe { + let value = BinaryType::index_column_unchecked(v, row.to_usize()); + row_ptr.is_bytes_eq(col_offset, value) + }) } - Column::Nullable(_) => unreachable!("nullable is unwrapped"), - other => self.row_match_generic_column(other, col_offset, (count, no_match_count)), + Column::Nullable(_) | Column::Null { .. } => unreachable!(), + column => self.match_validity_with(counts, validity, |row, row_ptr| { + let value = unsafe { AnyType::index_column_unchecked(column, row.to_usize()) }; + let scalar = unsafe { row_ptr.read_bytes(col_offset) }; + let scalar: Scalar = bincode_deserialize_from_slice(scalar).unwrap(); + + scalar.as_ref() == value + }), } } - fn row_match_column_type( + fn match_const_column( &mut self, - col: &Column, - validity: Option<&Bitmap>, - validity_offset: usize, + scalar: &Scalar, + col_offset: usize, + counts: (usize, usize), + ) -> (usize, usize) { + match scalar { + Scalar::Null => unreachable!(), + Scalar::Number(scalar) => with_number_mapped_type!(|NUM_TYPE| match scalar { + NumberScalar::NUM_TYPE(scalar) => { + self.match_scalar_type::>(scalar, col_offset, counts) + } + }), + Scalar::Decimal(scalar) => { + with_decimal_mapped_type!(|F| match scalar { + DecimalScalar::F(scalar, size) => { + with_decimal_mapped_type!(|T| match size.data_kind() { + DecimalDataKind::T => { + self.match_scalar_type::>( + &scalar.as_decimal(), + col_offset, + counts, + ) + } + }) + } + }) + } + Scalar::Boolean(value) => { + self.match_scalar_type::(value, col_offset, counts) + } + Scalar::Timestamp(value) => { + self.match_scalar_type::(value, col_offset, counts) + } + Scalar::Date(value) => self.match_scalar_type::(value, col_offset, counts), + Scalar::String(value) => self.match_with(counts, |_, row_ptr| unsafe { + row_ptr.is_bytes_eq(col_offset, value.as_bytes()) + }), + Scalar::Bitmap(v) | Scalar::Binary(v) | Scalar::Variant(v) | Scalar::Geometry(v) => { + self.match_with(counts, |_, row_ptr| unsafe { + row_ptr.is_bytes_eq(col_offset, v) + }) + } + _ => self.match_with(counts, |_, row_ptr| { + let row_data = unsafe { row_ptr.read_bytes(col_offset) }; + let stored: Scalar = bincode_deserialize_from_slice(row_data).unwrap(); + &stored == scalar + }), + } + } + + fn match_scalar_type( + &mut self, + value: &T::Scalar, col_offset: usize, - (count, no_match_count): (usize, usize), + counts: (usize, usize), ) -> (usize, usize) where T: AccessType, - for<'a, 'b> T::ScalarRef<'a>: PartialEq>, { - let col = T::try_downcast_column(col).unwrap(); + self.match_with(counts, |_, row_ptr| unsafe { + let scalar = row_ptr.read::(col_offset); + scalar == *value + }) + } - self.row_match_column_generic( - validity, - validity_offset, - (count, no_match_count), - |idx, row_ptr| unsafe { - let value = T::index_column_unchecked(&col, idx); - let scalar = row_ptr.read::(col_offset); - let scalar = T::to_scalar_ref(&scalar); - scalar == value - }, - ) + fn match_column_type( + &mut self, + col: &T::Column, + col_offset: usize, + validity: Option<(&Bitmap, usize)>, + counts: (usize, usize), + ) -> (usize, usize) + where + T: AccessType, + for<'a, 'b> T::ScalarRef<'a>: PartialEq>, + { + self.match_validity_with(counts, validity, |row, row_ptr| unsafe { + let value = T::index_column_unchecked(col, row.to_usize()); + let scalar = row_ptr.read::(col_offset); + let scalar = T::to_scalar_ref(&scalar); + scalar == value + }) } - fn row_match_column_generic( + fn match_with( &mut self, - validity: Option<&Bitmap>, - validity_offset: usize, (count, mut no_match_count): (usize, usize), compare_fn: F, ) -> (usize, usize) where - F: Fn(usize, &RowPtr) -> bool, + F: Fn(&RowID, &RowPtr) -> bool, { - let mut temp = self.get_temp(); - temp.reserve(count); - - if let Some(validity) = validity { - let is_all_set = validity.null_count() == 0; - for idx in self.group_compare_vector[..count].iter().copied() { - let is_set2 = unsafe { self.addresses[idx].read::(validity_offset) != 0 }; - let is_set = is_all_set || unsafe { validity.get_bit_unchecked(idx) }; - - let equal = if is_set && is_set2 { - compare_fn(idx, &self.addresses[idx]) - } else { - is_set == is_set2 - }; - - if equal { - temp.push(idx); - } else { - self.no_match_vector[no_match_count] = idx; - no_match_count += 1; - } - } - } else { - for idx in self.group_compare_vector[..count].iter().copied() { - if compare_fn(idx, &self.addresses[idx]) { - temp.push(idx); - } else { - self.no_match_vector[no_match_count] = idx; - no_match_count += 1; + assume(count <= self.compare.len()); + let mut matched = 0; + for i in 0..count { + let row = &self.compare[i]; + if compare_fn(row, &self.address[*row]) { + if i != matched { + self.compare[matched] = *row; } + matched += 1; + } else { + self.no_matched[no_match_count] = *row; + no_match_count += 1; } } - - let match_count = temp.len(); - self.group_compare_vector[..match_count].clone_from_slice(&temp); - self.save_temp(temp); - (match_count, no_match_count) + (matched, no_match_count) } - fn row_match_generic_column( + fn match_validity_with( &mut self, - col: &Column, - col_offset: usize, - (count, mut no_match_count): (usize, usize), - ) -> (usize, usize) { - let mut temp = self.get_temp(); - temp.reserve(count); - - for idx in self.group_compare_vector[..count].iter().copied() { - let value = unsafe { AnyType::index_column_unchecked(col, idx) }; - let scalar = unsafe { self.addresses[idx].read_bytes(col_offset) }; - let scalar: Scalar = bincode_deserialize_from_slice(scalar).unwrap(); - - if scalar.as_ref() == value { - temp.push(idx); - } else { - self.no_match_vector[no_match_count] = idx; - no_match_count += 1; - } + counts: (usize, usize), + validity: Option<(&Bitmap, usize)>, + compare_fn: F, + ) -> (usize, usize) + where + F: Fn(&RowID, &RowPtr) -> bool, + { + if let Some((validity, offset)) = validity { + self.match_with(counts, |row, row_ptr| { + let a = unsafe { validity.get_bit_unchecked(row.to_usize()) }; + let b = unsafe { row_ptr.read_bool(offset) }; + match (a, b) { + (true, true) => compare_fn(row, row_ptr), + (false, false) => true, + _ => false, + } + }) + } else { + self.match_with(counts, compare_fn) } - let match_count = temp.len(); - self.group_compare_vector[..match_count].clone_from_slice(&temp); - self.save_temp(temp); - (match_count, no_match_count) } } diff --git a/src/query/expression/src/aggregate/probe_state.rs b/src/query/expression/src/aggregate/probe_state.rs index ce8aaedaa4197..60d9c9a67f727 100644 --- a/src/query/expression/src/aggregate/probe_state.rs +++ b/src/query/expression/src/aggregate/probe_state.rs @@ -12,11 +12,14 @@ // See the License for the specific language governing permissions and // limitations under the License. +use std::ops::Index; +use std::ops::IndexMut; + use super::row_ptr::RowPtr; use super::StateAddr; use super::BATCH_SIZE; -pub type SelectVector = [usize; BATCH_SIZE]; +pub type SelectVector = [RowID; BATCH_SIZE]; /// ProbeState is the state to probe HT /// It could be reuse during multiple probe process @@ -29,12 +32,12 @@ pub struct ProbeState { pub(super) empty_vector: SelectVector, - pub(super) group_compare_vector: SelectVector, - pub(super) no_match_vector: SelectVector, + pub(super) group_compare_vector: [RowID; BATCH_SIZE], + pub(super) no_match_vector: [RowID; BATCH_SIZE], + pub(super) slots: [usize; BATCH_SIZE], pub(super) row_count: usize, - pub partition_entries: Vec<(usize, SelectVector)>, - pool: Vec>, + pub partition_entries: Vec<(u16, SelectVector)>, } impl Default for ProbeState { @@ -44,13 +47,13 @@ impl Default for ProbeState { addresses: [RowPtr::null(); BATCH_SIZE], page_index: [0; BATCH_SIZE], state_places: [StateAddr::null(); BATCH_SIZE], - group_compare_vector: [0; BATCH_SIZE], - no_match_vector: [0; BATCH_SIZE], - empty_vector: [0; BATCH_SIZE], + group_compare_vector: [RowID::default(); BATCH_SIZE], + no_match_vector: [RowID::default(); BATCH_SIZE], + empty_vector: [RowID::default(); BATCH_SIZE], + slots: [0; BATCH_SIZE], row_count: 0, partition_entries: vec![], - pool: vec![], } } } @@ -64,7 +67,6 @@ impl ProbeState { unsafe { let uninit = state.assume_init_mut(); uninit.partition_entries = vec![]; - uninit.pool = vec![]; for ptr in &mut uninit.addresses { *ptr = RowPtr::null(); @@ -72,7 +74,12 @@ impl ProbeState { for addr in &mut uninit.state_places { *addr = StateAddr::null() } - + for item in &mut uninit.group_compare_vector { + *item = Default::default() + } + for item in &mut uninit.no_match_vector { + *item = Default::default() + } state.assume_init() } } @@ -89,18 +96,42 @@ impl ProbeState { *count = 0; } } +} - pub(super) fn get_temp(&mut self) -> Vec { - match self.pool.pop() { - Some(mut vec) => { - vec.clear(); - vec - } - None => vec![], - } +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub struct RowID(pub u16); + +impl RowID { + #[inline] + pub fn to_usize(self) -> usize { + self.0 as usize + } +} + +impl Index for [T] { + type Output = T; + + fn index(&self, index: RowID) -> &T { + &self[index.0 as usize] + } +} + +impl IndexMut for [T] { + fn index_mut(&mut self, index: RowID) -> &mut T { + &mut self[index.0 as usize] } +} + +impl Index for Vec { + type Output = T; + + fn index(&self, index: RowID) -> &T { + &self[index.0 as usize] + } +} - pub(super) fn save_temp(&mut self, vec: Vec) { - self.pool.push(vec); +impl From for RowID { + fn from(v: usize) -> Self { + RowID(v as u16) } } diff --git a/src/query/expression/src/aggregate/row_ptr.rs b/src/query/expression/src/aggregate/row_ptr.rs index 3fea8a79d0c50..c88cd203c97e7 100644 --- a/src/query/expression/src/aggregate/row_ptr.rs +++ b/src/query/expression/src/aggregate/row_ptr.rs @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +use super::RowID; +use crate::types::StringColumn; use crate::StateAddr; use crate::StatesLayout; @@ -41,7 +43,7 @@ impl RowPtr { core::ptr::copy_nonoverlapping( value as *const T as *const u8, self.0.add(offset), - std::mem::size_of::(), + size_of::(), ); } @@ -61,6 +63,30 @@ impl RowPtr { scalar.len() == other.len() && databend_common_hashtable::fast_memcmp(scalar, other) } + pub(super) unsafe fn eq_string_view( + &self, + offset: usize, + str_view: &StringColumn, + row: RowID, + ) -> bool { + let row = row.to_usize(); + let v = str_view.views().get_unchecked(row); + let len = self.read::(offset); + if v.length != len { + return false; + } + let scalar = { + let data_ptr = self.read::(offset + size_of::()) as *const u8; + std::slice::from_raw_parts(data_ptr, len as _) + }; + let other = v.get_slice_unchecked(str_view.data_buffers()); + databend_common_hashtable::fast_memcmp(scalar, other) + } + + pub(super) unsafe fn read_bool(&self, offset: usize) -> bool { + self.read::(offset) != 0 + } + pub(super) unsafe fn write_u8(&mut self, offset: usize, value: u8) { self.write::(offset, &value); } diff --git a/src/query/expression/src/block.rs b/src/query/expression/src/block.rs index befb2d72cb17e..64eeb2849cb2d 100644 --- a/src/query/expression/src/block.rs +++ b/src/query/expression/src/block.rs @@ -26,6 +26,7 @@ use crate::schema::DataSchema; use crate::types::AccessType; use crate::types::AnyType; use crate::types::ArgType; +use crate::types::BooleanType; use crate::types::DataType; use crate::types::ValueType; use crate::Column; @@ -70,7 +71,10 @@ impl BlockEntry { } pub fn new_const_column(data_type: DataType, scalar: Scalar, num_rows: usize) -> Self { - debug_assert!(scalar.as_ref().is_value_of_type(&data_type)); + debug_assert!( + scalar.as_ref().is_value_of_type(&data_type), + "type not match: {scalar:?}, {data_type:?}" + ); BlockEntry::Const(scalar, data_type, num_rows) } @@ -80,13 +84,14 @@ impl BlockEntry { pub fn remove_nullable(self) -> Self { match self { - BlockEntry::Column(Column::Nullable(col)) => col.column().clone().into(), + BlockEntry::Column(Column::Nullable(col)) => { + let (col, _) = col.destructure(); + col.into() + } BlockEntry::Column(_) => self, BlockEntry::Const(scalar, DataType::Nullable(inner), num_rows) => { if scalar.is_null() { - let mut builder = ColumnBuilder::with_capacity(&inner, 1); - builder.push_default(); - BlockEntry::Const(builder.build_scalar(), *inner, num_rows) + BlockEntry::Const(Scalar::default_value(&inner), *inner, num_rows) } else { BlockEntry::Const(scalar, *inner, num_rows) } @@ -95,6 +100,38 @@ impl BlockEntry { } } + pub fn split_nullable(self) -> (Self, ColumnView) { + let n = self.len(); + match self { + BlockEntry::Column(Column::Nullable(col)) => { + let (column, validity) = col.destructure(); + let validity = if validity.null_count() == 0 { + ColumnView::Const(true, n) + } else if validity.true_count() == 0 { + ColumnView::Const(false, n) + } else { + ColumnView::Column(validity) + }; + (column.into(), validity) + } + BlockEntry::Column(_) => (self, ColumnView::Const(true, n)), + BlockEntry::Const(scalar, DataType::Nullable(inner), _) => { + if scalar.is_null() { + ( + BlockEntry::Const(Scalar::default_value(&inner), *inner, n), + ColumnView::Const(false, n), + ) + } else { + ( + BlockEntry::Const(scalar, *inner, n), + ColumnView::Const(true, n), + ) + } + } + _ => (self, ColumnView::Const(true, n)), + } + } + pub fn memory_size(&self) -> usize { match self { BlockEntry::Const(scalar, _, _) => scalar.as_ref().memory_size(), @@ -219,7 +256,7 @@ impl TryFrom> for BlockEntry { } } -#[derive(Debug, EnumAsInner)] +#[derive(Debug, EnumAsInner, Clone)] pub enum ColumnView { Const(T::Scalar, usize), Column(T::Column), @@ -233,6 +270,10 @@ impl ColumnView { } } + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + pub fn iter(&self) -> ColumnViewIter { match self { ColumnView::Const(scalar, num_rows) => { diff --git a/src/query/expression/src/lib.rs b/src/query/expression/src/lib.rs index 6323627861422..a104ccaa90fd2 100755 --- a/src/query/expression/src/lib.rs +++ b/src/query/expression/src/lib.rs @@ -44,6 +44,7 @@ #![feature(never_type)] #![feature(slice_as_array)] #![feature(new_zeroed_alloc)] +#![feature(iter_map_windows)] #[allow(dead_code)] mod block; diff --git a/src/query/expression/src/types/boolean.rs b/src/query/expression/src/types/boolean.rs index 3ac9f5189ea74..96c21e9584a5b 100644 --- a/src/query/expression/src/types/boolean.rs +++ b/src/query/expression/src/types/boolean.rs @@ -34,6 +34,7 @@ use crate::utils::arrow::bitmap_into_mut; use crate::values::Column; use crate::values::Scalar; use crate::ColumnBuilder; +use crate::ColumnView; use crate::ScalarRef; #[derive(Debug, Clone, PartialEq, Eq)] @@ -249,3 +250,41 @@ pub struct BooleanDomain { pub has_false: bool, pub has_true: bool, } + +impl ColumnView { + pub fn and_bitmap(&self, rhs: Option<&Bitmap>) -> Self { + debug_assert!(rhs.map(|rhs| rhs.len() == self.len()).unwrap_or(true)); + use ColumnView::*; + match (self, rhs) { + (Const(false, _), _) | (Const(true, _), None) => self.clone(), + (Const(true, n), Some(rhs)) => { + if rhs.null_count() == 0 { + Const(true, *n) + } else if rhs.true_count() == 0 { + Const(false, *n) + } else { + Column(rhs.clone()) + } + } + (Column(b), None) => { + if b.null_count() == 0 { + Const(true, b.len()) + } else if b.true_count() == 0 { + Const(false, b.len()) + } else { + Column(b.clone()) + } + } + (Column(b), Some(rhs)) => { + let merge = b & rhs; + if merge.null_count() == 0 { + Const(true, merge.len()) + } else if merge.true_count() == 0 { + Const(false, merge.len()) + } else { + Column(merge) + } + } + } + } +} diff --git a/src/query/expression/src/utils/mod.rs b/src/query/expression/src/utils/mod.rs index c7f338b172e75..80f242043411c 100644 --- a/src/query/expression/src/utils/mod.rs +++ b/src/query/expression/src/utils/mod.rs @@ -209,7 +209,14 @@ pub fn column_merge_validity(entry: &BlockEntry, bitmap: Option) -> Opti } } BlockEntry::Column(Column::Nullable(c)) => match bitmap { - None => Some(c.validity().clone()), + None => { + let validity = c.validity(); + if validity.null_count() == 0 { + None + } else { + Some(validity.clone()) + } + } Some(v) => Some(&c.validity & (&v)), }, _ => bitmap, diff --git a/src/query/expression/src/values.rs b/src/query/expression/src/values.rs index 73fd6995fde8e..6d72495197ee0 100755 --- a/src/query/expression/src/values.rs +++ b/src/query/expression/src/values.rs @@ -860,6 +860,7 @@ impl ScalarRef<'_> { .all(|(val, ty)| val.is_value_of_type(&ty)) } (ScalarRef::Vector(val), DataType::Vector(ty)) => val.data_type() == ty, + (ScalarRef::Opaque(val), ty) => val.data_type() == ty, _ => false, }, } diff --git a/src/query/functions/benches/bench.rs b/src/query/functions/benches/bench.rs index 198105930095d..fa47167fb5fdf 100644 --- a/src/query/functions/benches/bench.rs +++ b/src/query/functions/benches/bench.rs @@ -76,7 +76,7 @@ mod bitmap { use databend_common_expression::BlockEntry; use databend_common_expression::Column; use databend_common_expression::FromData; - use databend_common_functions::aggregates::eval_aggr_for_test; + use databend_common_functions::aggregates::eval_aggr; use databend_common_io::deserialize_bitmap; use databend_common_io::HybridBitmap; @@ -162,15 +162,9 @@ mod bitmap { } fn eval_bitmap_result(entry: &BlockEntry, rows: usize, agg_name: &'static str) -> HybridBitmap { - let (result_column, _) = eval_aggr_for_test( - agg_name, - vec![], - std::slice::from_ref(entry), - rows, - false, - vec![], - ) - .unwrap_or_else(|_| panic!("{agg_name} evaluation failed")); + let (result_column, _) = + eval_aggr(agg_name, vec![], std::slice::from_ref(entry), rows, vec![]) + .unwrap_or_else(|_| panic!("{agg_name} evaluation failed")); let Column::Bitmap(result) = result_column.remove_nullable() else { panic!("{agg_name} should return a Bitmap column"); diff --git a/src/query/functions/src/aggregates/adaptors/aggregate_combinator_if.rs b/src/query/functions/src/aggregates/adaptors/aggregate_combinator_if.rs index 2b75f76f851b5..97fe39e85136f 100644 --- a/src/query/functions/src/aggregates/adaptors/aggregate_combinator_if.rs +++ b/src/query/functions/src/aggregates/adaptors/aggregate_combinator_if.rs @@ -22,8 +22,10 @@ use databend_common_expression::types::Bitmap; use databend_common_expression::types::BooleanType; use databend_common_expression::types::DataType; use databend_common_expression::AggrStateRegistry; +use databend_common_expression::BlockEntry; use databend_common_expression::Column; use databend_common_expression::ColumnBuilder; +use databend_common_expression::ColumnView; use databend_common_expression::ProjectedBlock; use databend_common_expression::Scalar; use databend_common_expression::StateSerdeItem; @@ -111,24 +113,29 @@ impl AggregateFunction for AggregateIfCombinator { fn accumulate( &self, place: AggrState, - columns: ProjectedBlock, + block: ProjectedBlock, validity: Option<&Bitmap>, input_rows: usize, ) -> Result<()> { if self.always_false { return Ok(()); } - let predicate = - BooleanType::try_downcast_column(&columns[self.argument_len - 1].to_column()).unwrap(); - let bitmap = match validity { - Some(validity) => validity & (&predicate), - None => predicate, + let view = block[self.argument_len - 1] + .downcast::() + .unwrap(); + let predicate = match view.and_bitmap(validity) { + ColumnView::Const(true, _) => None, + ColumnView::Const(false, _) => { + return Ok(()); + } + ColumnView::Column(predicate) => Some(predicate), }; + self.nested.accumulate( place, - columns.slice(0..self.argument_len - 1), - Some(&bitmap), + block.slice(0..self.argument_len - 1), + predicate.as_ref(), input_rows, ) } @@ -137,33 +144,50 @@ impl AggregateFunction for AggregateIfCombinator { &self, places: &[StateAddr], loc: &[AggrStateLoc], - columns: ProjectedBlock, - _input_rows: usize, + block: ProjectedBlock, + input_rows: usize, ) -> Result<()> { if self.always_false { return Ok(()); } - let predicate: Bitmap = - BooleanType::try_downcast_column(&columns[self.argument_len - 1].to_column()).unwrap(); - let (columns, row_size) = - self.filter_column(columns.slice(0..self.argument_len - 1), &predicate); - let new_places = Self::filter_place(places, &predicate); - - let new_places_slice = new_places.as_slice(); - let entries: Vec<_> = columns.into_iter().map(|c| c.into()).collect(); - self.nested - .accumulate_keys(new_places_slice, loc, (&entries).into(), row_size) + + match &block[self.argument_len - 1] { + BlockEntry::Column(Column::Boolean(predicate)) => { + let (entries, num_rows) = + self.filter_column(block.slice(0..self.argument_len - 1), predicate); + let new_places = Self::filter_place(places, predicate); + + let new_places_slice = new_places.as_slice(); + self.nested + .accumulate_keys(new_places_slice, loc, (&entries).into(), num_rows) + } + BlockEntry::Const(Scalar::Boolean(v), _, _) => { + if !*v { + return Ok(()); + } + self.nested.accumulate_keys( + places, + loc, + block.slice(0..self.argument_len - 1), + input_rows, + ) + } + _ => unreachable!(), + } } - fn accumulate_row(&self, place: AggrState, columns: ProjectedBlock, row: usize) -> Result<()> { + fn accumulate_row(&self, place: AggrState, block: ProjectedBlock, row: usize) -> Result<()> { if self.always_false { return Ok(()); } - let predicate: Bitmap = - BooleanType::try_downcast_column(&columns[self.argument_len - 1].to_column()).unwrap(); - if predicate.get_bit(row) { + + let predicate = block[self.argument_len - 1] + .downcast::() + .unwrap(); + + if predicate.index(row).unwrap() { self.nested - .accumulate_row(place, columns.slice(0..self.argument_len - 1), row)?; + .accumulate_row(place, block.slice(0..self.argument_len - 1), row)?; } Ok(()) } @@ -185,7 +209,7 @@ impl AggregateFunction for AggregateIfCombinator { &self, places: &[StateAddr], loc: &[AggrStateLoc], - state: &databend_common_expression::BlockEntry, + state: &BlockEntry, filter: Option<&Bitmap>, ) -> Result<()> { self.nested.batch_merge(places, loc, state, filter) @@ -230,15 +254,18 @@ impl fmt::Display for AggregateIfCombinator { impl AggregateIfCombinator { #[inline] - fn filter_column(&self, columns: ProjectedBlock, predicate: &Bitmap) -> (Vec, usize) { - let columns = columns + fn filter_column(&self, block: ProjectedBlock, predicate: &Bitmap) -> (Vec, usize) { + let entries = block .iter() - .map(|c| c.to_column().filter(predicate)) - .collect::>(); - - let rows = predicate.len() - predicate.null_count(); - - (columns, rows) + .map(|entry| match entry { + BlockEntry::Const(scalar, data_type, _) => { + BlockEntry::Const(scalar.clone(), data_type.clone(), predicate.true_count()) + } + BlockEntry::Column(column) => column.filter(predicate).into(), + }) + .collect(); + + (entries, predicate.true_count()) } fn filter_place(places: &[StateAddr], predicate: &Bitmap) -> StateAddrs { diff --git a/src/query/functions/src/aggregates/aggregate_array_agg.rs b/src/query/functions/src/aggregates/aggregate_array_agg.rs index c573b2ea0604f..f375a77449f86 100644 --- a/src/query/functions/src/aggregates/aggregate_array_agg.rs +++ b/src/query/functions/src/aggregates/aggregate_array_agg.rs @@ -48,6 +48,7 @@ use databend_common_expression::AggrStateType; use databend_common_expression::BlockEntry; use databend_common_expression::Column; use databend_common_expression::ColumnBuilder; +use databend_common_expression::ColumnView; use databend_common_expression::ProjectedBlock; use databend_common_expression::Scalar; use databend_common_expression::ScalarRef; @@ -94,13 +95,12 @@ where T: ValueType self.values.push(T::to_owned_scalar(other.unwrap())); } - fn add_batch(&mut self, column: &T::Column, _validity: Option<&Bitmap>) -> Result<()> { - let column_len = T::column_len(column); - if column_len == 0 { + fn add_batch(&mut self, column: ColumnView, _validity: Option<&Bitmap>) -> Result<()> { + if column.is_empty() { return Ok(()); } - let column_iter = T::iter_column(column); - for val in column_iter { + + for val in column.iter() { self.values.push(T::to_owned_scalar(val)); } @@ -196,20 +196,23 @@ where T: SimpleType + Debug } } - fn add_batch(&mut self, column: &Buffer, validity: Option<&Bitmap>) -> Result<()> { - let length = column.len(); - if length == 0 { + fn add_batch( + &mut self, + column: ColumnView>, + validity: Option<&Bitmap>, + ) -> Result<()> { + if column.is_empty() { return Ok(()); } if let Some(validity) = validity { for (value, valid) in column.iter().zip(validity) { if valid { - self.values.push(*value); + self.values.push(value); } } } else { - self.values.extend(column.iter().copied()); + self.values.extend(column.iter()); } Ok(()) } @@ -305,8 +308,12 @@ where V: ZeroSizeType } } - fn add_batch(&mut self, length: &usize, validity: Option<&Bitmap>) -> Result<()> { - if IS_NULL || *length == 0 { + fn add_batch( + &mut self, + column: ColumnView>, + validity: Option<&Bitmap>, + ) -> Result<()> { + if IS_NULL || column.is_empty() { return Ok(()); } @@ -317,7 +324,11 @@ where V: ZeroSizeType } } } else { - self.validity.extend_constant(*length, true); + let length = match column { + ColumnView::Const(_, n) => n, + ColumnView::Column(n) => n, + }; + self.validity.extend_constant(length, true); } Ok(()) } @@ -408,14 +419,14 @@ where T: ArgType + Debug + std::marker::Send } } - fn add_batch(&mut self, column: &T::Column, validity: Option<&Bitmap>) -> Result<()> { - let length = T::column_len(column); + fn add_batch(&mut self, column: ColumnView, validity: Option<&Bitmap>) -> Result<()> { + let length = column.len(); if length == 0 { return Ok(()); } if let Some(validity) = validity { - for (scalar, valid) in T::iter_column(column).zip(validity) { + for (scalar, valid) in column.iter().zip(validity) { if valid { let val = T::upcast_scalar(T::to_owned_scalar(scalar)); self.builder.put_slice(val.as_bytes().unwrap()); @@ -423,7 +434,7 @@ where T: ArgType + Debug + std::marker::Send } } } else { - for scalar in T::iter_column(column) { + for scalar in column.iter() { let val = T::upcast_scalar(T::to_owned_scalar(scalar)); self.builder.put_slice(val.as_bytes().unwrap()); self.builder.commit_row(); @@ -580,14 +591,17 @@ where _input_rows: usize, ) -> Result<()> { let state = place.get::(); - let entry = &columns[0]; - if entry.data_type().is_nullable() { - let nullable_column = - NullableType::::try_downcast_column(&entry.to_column()).unwrap(); - state.add_batch(nullable_column.column(), Some(nullable_column.validity())) - } else { - let column = T::try_downcast_column(&entry.to_column()).unwrap(); - state.add_batch(&column, None) + match &columns[0] { + BlockEntry::Const(Scalar::Null, DataType::Nullable(_), _) => Ok(()), + entry @ BlockEntry::Const(_, _, _) => { + let column = entry.clone().remove_nullable().downcast().unwrap(); + state.add_batch(column, None) + } + BlockEntry::Column(Column::Nullable(box nullable_column)) => { + let c = T::try_downcast_column(nullable_column.column()).unwrap(); + state.add_batch(ColumnView::Column(c), Some(nullable_column.validity())) + } + entry => state.add_batch(entry.downcast().unwrap(), None), } } @@ -595,55 +609,46 @@ where &self, places: &[StateAddr], loc: &[AggrStateLoc], - columns: ProjectedBlock, + block: ProjectedBlock, _input_rows: usize, ) -> Result<()> { - match &columns[0].to_column() { - Column::Nullable(box nullable_column) => { - let column = T::try_downcast_column(nullable_column.column()).unwrap(); - let column_iter = T::iter_column(&column); - column_iter - .zip(nullable_column.validity().iter().zip(places.iter())) - .for_each(|(v, (valid, place))| { - let state = AggrState::new(*place, loc).get::(); - if valid { - state.add(Some(v.clone())) - } else { - state.add(None) - } - }); - } - column => { - let column = T::try_downcast_column(column).unwrap(); - let column_iter = T::iter_column(&column); - column_iter.zip(places.iter()).for_each(|(v, place)| { + let entry = &block[0]; + if entry.data_type().is_nullable() { + entry + .downcast::>() + .unwrap() + .iter() + .zip(places.iter()) + .for_each(|(v, place)| { let state = AggrState::new(*place, loc).get::(); - state.add(Some(v.clone())) + state.add(v) + }); + } else { + entry + .downcast::() + .unwrap() + .iter() + .zip(places.iter()) + .for_each(|(v, place)| { + let state = AggrState::new(*place, loc).get::(); + state.add(Some(v)) }); - } } - Ok(()) } - fn accumulate_row(&self, place: AggrState, columns: ProjectedBlock, row: usize) -> Result<()> { + fn accumulate_row(&self, place: AggrState, block: ProjectedBlock, row: usize) -> Result<()> { let state = place.get::(); - match &columns[0].to_column() { - Column::Nullable(box nullable_column) => { - let valid = nullable_column.validity().get_bit(row); - if valid { - let column = T::try_downcast_column(nullable_column.column()).unwrap(); - let v = T::index_column(&column, row); - state.add(v); - } else { - state.add(None); - } - } - column => { - let column = T::try_downcast_column(column).unwrap(); - let v = T::index_column(&column, row); - state.add(v); - } + let entry = &block[0]; + + if entry.data_type().is_nullable() { + let view = entry.downcast::>().unwrap(); + let v = view.index(row).unwrap(); + state.add(v); + } else { + let view = entry.downcast::().unwrap(); + let v = view.index(row).unwrap(); + state.add(Some(v)); } Ok(()) diff --git a/src/query/functions/src/aggregates/aggregate_array_moving.rs b/src/query/functions/src/aggregates/aggregate_array_moving.rs index 5481f76aa5bb4..6f3664feadb81 100644 --- a/src/query/functions/src/aggregates/aggregate_array_moving.rs +++ b/src/query/functions/src/aggregates/aggregate_array_moving.rs @@ -27,8 +27,8 @@ use databend_common_expression::with_number_mapped_type; use databend_common_expression::AggrStateRegistry; use databend_common_expression::AggrStateType; use databend_common_expression::BlockEntry; -use databend_common_expression::Column; use databend_common_expression::ColumnBuilder; +use databend_common_expression::ColumnView; use databend_common_expression::ProjectedBlock; use databend_common_expression::Scalar; use databend_common_expression::ScalarRef; @@ -90,47 +90,56 @@ where TSum: Number + AsPrimitive + std::ops::AddAssign + std::ops::SubAssign, { fn accumulate_row(&mut self, entry: &BlockEntry, row: usize) -> Result<()> { - let column = &entry.to_column(); - let buffer = match column { - Column::Null { .. } => { - self.values.push(T::default()); - return Ok(()); + let val = match entry.data_type() { + DataType::Null => None, + DataType::Nullable(_) => { + let view = entry + .clone() + .downcast::>>() + .unwrap(); + view.index(row).unwrap() } - Column::Nullable(box nullable_column) => { - NumberType::::try_downcast_column(&nullable_column.column).unwrap() + _ => { + let view = entry.clone().downcast::>().unwrap(); + Some(view.index(row).unwrap()) } - _ => NumberType::::try_downcast_column(column).unwrap(), }; - self.values.push(buffer[row]); + self.values.push(val.unwrap_or_default()); Ok(()) } fn accumulate(&mut self, entry: &BlockEntry, validity: Option<&Bitmap>) -> Result<()> { - let column = match entry.data_type() { - DataType::Null => { + if entry.data_type().is_null() { + for _ in 0..entry.len() { + self.values.push(T::default()); + } + return Ok(()); + } + + let (not_null, nulls) = entry.clone().split_nullable(); + match nulls.and_bitmap(validity) { + ColumnView::Const(false, _) => { for _ in 0..entry.len() { self.values.push(T::default()); } return Ok(()); } - _ => entry - .clone() - .remove_nullable() - .downcast::>() - .unwrap(), - }; - if let Some(validity) = validity { - column.iter().zip(validity.iter()).for_each(|(v, b)| { - if b { + ColumnView::Const(true, _) => { + let view = not_null.downcast::>().unwrap(); + view.iter().for_each(|v| { self.values.push(v); - } else { - self.values.push(T::default()); + }); + } + ColumnView::Column(validity) => { + let view = not_null.downcast::>().unwrap(); + for (v, b) in view.iter().zip(validity) { + if b { + self.values.push(v); + } else { + self.values.push(T::default()); + } } - }); - } else { - column.iter().for_each(|v| { - self.values.push(v); - }); + } } Ok(()) } @@ -140,17 +149,29 @@ where loc: &[AggrStateLoc], entry: &BlockEntry, ) -> Result<()> { - let buffer = match entry.to_column() { - Column::Null { len } => Buffer::from(vec![T::default(); len]), - Column::Nullable(box nullable_column) => { - NumberType::::try_downcast_column(&nullable_column.column).unwrap() + match entry.data_type() { + DataType::Null => { + for place in places { + let state = AggrState::new(*place, loc).get::(); + state.values.push(T::default()); + } } - column => NumberType::::try_downcast_column(&column).unwrap(), - }; - buffer.iter().zip(places.iter()).for_each(|(c, place)| { - let state = AggrState::new(*place, loc).get::(); - state.values.push(*c); - }); + DataType::Nullable(_) => { + let view = entry.downcast::>>().unwrap(); + view.iter().zip(places.iter()).for_each(|(c, place)| { + let state = AggrState::new(*place, loc).get::(); + state.values.push(c.unwrap_or_default()); + }); + } + _ => { + let view = entry.downcast::>().unwrap(); + view.iter().zip(places.iter()).for_each(|(c, place)| { + let state = AggrState::new(*place, loc).get::(); + state.values.push(c); + }); + } + } + Ok(()) } @@ -297,50 +318,55 @@ where T: Decimal + std::ops::SubAssign { fn accumulate_row(&mut self, entry: &BlockEntry, row: usize) -> Result<()> { - let column = &entry.to_column(); - let buffer = match column { - Column::Null { .. } => { + match entry.data_type() { + DataType::Null => { self.values.push(T::default()); - return Ok(()); } - Column::Nullable(box nullable_column) => { - T::try_downcast_column(&nullable_column.column).unwrap().0 + DataType::Nullable(_) => { + let view = entry.downcast::>>().unwrap(); + self.values + .push(view.index(row).unwrap().unwrap_or_default()); } - _ => T::try_downcast_column(column).unwrap().0, - }; - self.values.push(buffer[row]); + _ => { + let view = entry.downcast::>().unwrap(); + self.values.push(view.index(row).unwrap()); + } + } Ok(()) } fn accumulate(&mut self, entry: &BlockEntry, validity: Option<&Bitmap>) -> Result<()> { - let column = &entry.to_column(); - let buffer = match column { - Column::Null { len } => { - for _ in 0..*len { + if entry.data_type().is_null() { + for _ in 0..entry.len() { + self.values.push(T::default()); + } + return Ok(()); + } + + let (not_null, nulls) = entry.clone().split_nullable(); + match nulls.and_bitmap(validity) { + ColumnView::Const(false, _) => { + for _ in 0..entry.len() { self.values.push(T::default()); } return Ok(()); } - Column::Nullable(box nullable_column) => { - T::try_downcast_column(&nullable_column.column).unwrap().0 + ColumnView::Const(true, _) => { + let view = not_null.downcast::>().unwrap(); + view.iter().for_each(|v| { + self.values.push(v); + }); } - _ => T::try_downcast_column(column).unwrap().0, - }; - match validity { - Some(validity) => { - for (i, v) in validity.iter().enumerate() { - if v { - self.values.push(buffer[i]); + ColumnView::Column(validity) => { + let view = not_null.downcast::>().unwrap(); + for (v, b) in view.iter().zip(validity) { + if b { + self.values.push(v); } else { self.values.push(T::default()); } } } - None => { - for v in buffer.iter() { - self.values.push(*v); - } - } } Ok(()) } @@ -350,17 +376,28 @@ where T: Decimal loc: &[AggrStateLoc], entry: &BlockEntry, ) -> Result<()> { - let buffer = match entry.to_column() { - Column::Null { len } => Buffer::from(vec![T::default(); len]), - Column::Nullable(box nullable_column) => { - T::try_downcast_column(&nullable_column.column).unwrap().0 + match entry.data_type() { + DataType::Null => { + for place in places { + let state = AggrState::new(*place, loc).get::(); + state.values.push(T::default()); + } } - column => T::try_downcast_column(&column).unwrap().0, - }; - buffer.iter().zip(places.iter()).for_each(|(c, place)| { - let state = AggrState::new(*place, loc).get::(); - state.values.push(*c); - }); + DataType::Nullable(_) => { + let view = entry.downcast::>>().unwrap(); + view.iter().zip(places.iter()).for_each(|(c, place)| { + let state = AggrState::new(*place, loc).get::(); + state.values.push(c.unwrap_or_default()); + }); + } + _ => { + let view = entry.downcast::>().unwrap(); + view.iter().zip(places.iter()).for_each(|(c, place)| { + let state = AggrState::new(*place, loc).get::(); + state.values.push(c); + }); + } + } Ok(()) } diff --git a/src/query/functions/src/aggregates/aggregate_bitmap.rs b/src/query/functions/src/aggregates/aggregate_bitmap.rs index 6da6a58fe265f..dcdde29a53dac 100644 --- a/src/query/functions/src/aggregates/aggregate_bitmap.rs +++ b/src/query/functions/src/aggregates/aggregate_bitmap.rs @@ -250,7 +250,7 @@ where _input_rows: usize, ) -> Result<()> { let view = entries[0].downcast::().unwrap(); - if view.len() == 0 { + if view.is_empty() { return Ok(()); } @@ -447,7 +447,7 @@ where _input_rows: usize, ) -> Result<()> { let view = entries[0].downcast::>().unwrap(); - if view.len() == 0 { + if view.is_empty() { return Ok(()); } let state = place.get::(); @@ -706,11 +706,18 @@ where &self, places: &[StateAddr], loc: &[AggrStateLoc], - columns: ProjectedBlock, + block: ProjectedBlock, _input_rows: usize, ) -> Result<()> { - let predicate = self.get_filter_bitmap(columns); - let entry = columns[0].to_column().filter(&predicate).into(); + let predicate = self.get_filter_bitmap(block); + let entry = match &block[0] { + BlockEntry::Const(scalar, data_type, _) => BlockEntry::new_const_column( + data_type.clone(), + scalar.clone(), + predicate.true_count(), + ), + BlockEntry::Column(column) => column.filter(&predicate).into(), + }; let new_places = Self::filter_place(places, &predicate); let new_places_slice = new_places.as_slice(); diff --git a/src/query/functions/src/aggregates/aggregate_count.rs b/src/query/functions/src/aggregates/aggregate_count.rs index 47233ed85a34e..b878a44855fc3 100644 --- a/src/query/functions/src/aggregates/aggregate_count.rs +++ b/src/query/functions/src/aggregates/aggregate_count.rs @@ -99,16 +99,17 @@ impl AggregateFunction for AggregateCountFunction { fn accumulate( &self, place: AggrState, - columns: ProjectedBlock, + block: ProjectedBlock, validity: Option<&Bitmap>, input_rows: usize, ) -> Result<()> { let state = place.get::(); - let nulls = if columns.is_empty() { + let nulls = if block.is_empty() { validity.map(|v| v.null_count()).unwrap_or(0) } else { - match &columns[0].to_column() { - Column::Nullable(c) => validity + match &block[0] { + BlockEntry::Const(Scalar::Null, DataType::Nullable(_), n) => *n, + BlockEntry::Column(Column::Nullable(c)) => validity .map(|v| v & (&c.validity)) .unwrap_or_else(|| c.validity.clone()) .null_count(), diff --git a/src/query/functions/src/aggregates/aggregate_json_array_agg.rs b/src/query/functions/src/aggregates/aggregate_json_array_agg.rs index 76bea22c0ebbc..bc8a1950e2b9b 100644 --- a/src/query/functions/src/aggregates/aggregate_json_array_agg.rs +++ b/src/query/functions/src/aggregates/aggregate_json_array_agg.rs @@ -33,6 +33,7 @@ use databend_common_expression::AggrStateType; use databend_common_expression::BlockEntry; use databend_common_expression::Column; use databend_common_expression::ColumnBuilder; +use databend_common_expression::ColumnView; use databend_common_expression::ProjectedBlock; use databend_common_expression::Scalar; use databend_common_expression::ScalarRef; @@ -88,20 +89,19 @@ where } } - fn add_batch(&mut self, column: &T::Column, validity: Option<&Bitmap>) -> Result<()> { - let column_len = T::column_len(column); + fn add_batch(&mut self, column: ColumnView, validity: Option<&Bitmap>) -> Result<()> { + let column_len = column.len(); if column_len == 0 { return Ok(()); } - let column_iter = T::iter_column(column); if let Some(validity) = validity { - for (val, valid) in column_iter.zip(validity.iter()) { + for (val, valid) in column.iter().zip(validity.iter()) { if valid { self.values.push(T::to_owned_scalar(val)); } } } else { - for val in column_iter { + for val in column.iter() { self.values.push(T::to_owned_scalar(val)); } } @@ -175,16 +175,16 @@ where } #[derive(Clone)] -struct AggregateJsonArrayAggFunction { +struct AggregateJsonArrayAggFunction { display_name: String, return_type: DataType, - _t: PhantomData, + _t: PhantomData, } -impl AggregateFunction for AggregateJsonArrayAggFunction +impl AggregateFunction for AggregateJsonArrayAggFunction where T: ValueType, - State: ScalarStateFunc, + T::Scalar: borsh::BorshSerialize + borsh::BorshDeserialize, { fn name(&self) -> &str { "AggregateJsonArrayAggFunction" @@ -195,11 +195,11 @@ where } fn init_state(&self, place: AggrState) { - place.write(State::new); + place.write(JsonArrayAggState::::new); } fn register_state(&self, registry: &mut AggrStateRegistry) { - registry.register(AggrStateType::Custom(Layout::new::())); + registry.register(AggrStateType::Custom(Layout::new::>())); } fn accumulate( @@ -209,15 +209,20 @@ where _validity: Option<&Bitmap>, _input_rows: usize, ) -> Result<()> { - let state = place.get::(); - match &columns[0].to_column() { - Column::Nullable(box nullable_column) => { + let state = place.get::>(); + match &columns[0] { + BlockEntry::Const(Scalar::Null, _, _) => Ok(()), + entry @ BlockEntry::Const(_, _, _) => { + let column = entry.clone().remove_nullable().downcast::().unwrap(); + state.add_batch(column, None) + } + BlockEntry::Column(Column::Nullable(box nullable_column)) => { let column = T::try_downcast_column(&nullable_column.column).unwrap(); - state.add_batch(&column, Some(&nullable_column.validity)) + state.add_batch(ColumnView::Column(column), Some(&nullable_column.validity)) } - _ => { - let column = T::try_downcast_column(&columns[0].to_column()).unwrap(); - state.add_batch(&column, None) + entry => { + let c = entry.downcast::().unwrap(); + state.add_batch(c, None) } } } @@ -226,62 +231,52 @@ where &self, places: &[StateAddr], loc: &[AggrStateLoc], - columns: ProjectedBlock, + block: ProjectedBlock, _input_rows: usize, ) -> Result<()> { - match &columns[0].to_column() { - Column::Nullable(box nullable_column) => { - let column = T::try_downcast_column(&nullable_column.column).unwrap(); - let column_iter = T::iter_column(&column); - column_iter - .zip(nullable_column.validity.iter().zip(places.iter())) - .for_each(|(v, (valid, place))| { - let state = AggrState::new(*place, loc).get::(); - if valid { - state.add(Some(v.clone())) - } else { - state.add(None) - } - }); - } - _ => { - let column = T::try_downcast_column(&columns[0].to_column()).unwrap(); - let column_iter = T::iter_column(&column); - column_iter.zip(places.iter()).for_each(|(v, place)| { - let state = AggrState::new(*place, loc).get::(); - state.add(Some(v.clone())) + let entry = &block[0]; + if entry.data_type().is_nullable() { + entry + .downcast::>() + .unwrap() + .iter() + .zip(places.iter()) + .for_each(|(v, place)| { + let state = AggrState::new(*place, loc).get::>(); + state.add(v) + }); + } else { + entry + .downcast::() + .unwrap() + .iter() + .zip(places.iter()) + .for_each(|(v, place)| { + let state = AggrState::new(*place, loc).get::>(); + state.add(Some(v)) }); - } } Ok(()) } - fn accumulate_row(&self, place: AggrState, columns: ProjectedBlock, row: usize) -> Result<()> { - let state = place.get::(); - match &columns[0].to_column() { - Column::Nullable(box nullable_column) => { - let valid = nullable_column.validity.get_bit(row); - if valid { - let column = T::try_downcast_column(&nullable_column.column).unwrap(); - let v = T::index_column(&column, row); - state.add(v); - } else { - state.add(None); - } - } - _ => { - let column = T::try_downcast_column(&columns[0].to_column()).unwrap(); - let v = T::index_column(&column, row); - state.add(v); - } + fn accumulate_row(&self, place: AggrState, block: ProjectedBlock, row: usize) -> Result<()> { + let state = place.get::>(); + let entry = &block[0]; + if entry.data_type().is_nullable() { + let view = entry.downcast::>().unwrap(); + let v = view.index(row).unwrap(); + state.add(v); + } else { + let view = entry.downcast::().unwrap(); + let v = view.index(row).unwrap(); + state.add(Some(v)); } - Ok(()) } fn serialize_type(&self) -> Vec { - State::serialize_type(None) + JsonArrayAggState::::serialize_type(None) } fn batch_serialize( @@ -290,7 +285,7 @@ where loc: &[AggrStateLoc], builders: &mut [ColumnBuilder], ) -> Result<()> { - State::batch_serialize(places, loc, builders) + JsonArrayAggState::::batch_serialize(places, loc, builders) } fn batch_merge( @@ -300,12 +295,12 @@ where state: &BlockEntry, filter: Option<&Bitmap>, ) -> Result<()> { - State::batch_merge(places, loc, state, filter) + JsonArrayAggState::::batch_merge(places, loc, state, filter) } fn merge_states(&self, place: AggrState, rhs: AggrState) -> Result<()> { - let state = place.get::(); - let other = rhs.get::(); + let state = place.get::>(); + let other = rhs.get::>(); state.merge(other) } @@ -315,7 +310,7 @@ where _read_only: bool, builder: &mut ColumnBuilder, ) -> Result<()> { - let state = place.get::(); + let state = place.get::>(); state.merge_result(builder) } @@ -324,24 +319,24 @@ where } unsafe fn drop_state(&self, place: AggrState) { - let state = place.get::(); + let state = place.get::>(); std::ptr::drop_in_place(state); } } -impl fmt::Display for AggregateJsonArrayAggFunction { +impl fmt::Display for AggregateJsonArrayAggFunction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.display_name) } } -impl AggregateJsonArrayAggFunction +impl AggregateJsonArrayAggFunction where T: ValueType, - State: ScalarStateFunc, + T::Scalar: borsh::BorshSerialize + borsh::BorshDeserialize, { fn try_create(display_name: &str, return_type: DataType) -> Result> { - let func = AggregateJsonArrayAggFunction:: { + let func = AggregateJsonArrayAggFunction:: { display_name: display_name.to_string(), return_type, _t: PhantomData, @@ -360,8 +355,7 @@ fn try_create_aggregate_json_array_agg_function( assert_unary_arguments(display_name, argument_types.len())?; let return_type = DataType::Variant; - type State = JsonArrayAggState; - AggregateJsonArrayAggFunction::::try_create(display_name, return_type) + AggregateJsonArrayAggFunction::::try_create(display_name, return_type) } pub fn aggregate_json_array_agg_function_desc() -> AggregateFunctionDescription { diff --git a/src/query/functions/src/aggregates/aggregate_scalar_state.rs b/src/query/functions/src/aggregates/aggregate_scalar_state.rs index 7cfdfedc35ffe..8c56aaf837ee9 100644 --- a/src/query/functions/src/aggregates/aggregate_scalar_state.rs +++ b/src/query/functions/src/aggregates/aggregate_scalar_state.rs @@ -19,6 +19,7 @@ use databend_common_expression::types::AccessType; use databend_common_expression::types::Bitmap; use databend_common_expression::types::ValueType; use databend_common_expression::ColumnBuilder; +use databend_common_expression::ColumnView; use super::StateSerde; @@ -139,7 +140,7 @@ impl ChangeIf for CmpAny { pub(super) trait ScalarStateFunc: StateSerde + Send + 'static { fn new() -> Self; fn add(&mut self, other: Option>); - fn add_batch(&mut self, column: &T::Column, validity: Option<&Bitmap>) -> Result<()>; + fn add_batch(&mut self, column: ColumnView, validity: Option<&Bitmap>) -> Result<()>; fn merge(&mut self, rhs: &Self) -> Result<()>; fn merge_result(&mut self, builder: &mut ColumnBuilder) -> Result<()>; } diff --git a/src/query/functions/src/aggregates/aggregate_st_collect.rs b/src/query/functions/src/aggregates/aggregate_st_collect.rs index 119fd34669026..1cdb80236452e 100644 --- a/src/query/functions/src/aggregates/aggregate_st_collect.rs +++ b/src/query/functions/src/aggregates/aggregate_st_collect.rs @@ -25,12 +25,14 @@ use databend_common_expression::types::ArrayType; use databend_common_expression::types::Bitmap; use databend_common_expression::types::DataType; use databend_common_expression::types::GeometryType; +use databend_common_expression::types::NullableType; use databend_common_expression::types::ValueType; use databend_common_expression::AggrStateRegistry; use databend_common_expression::AggrStateType; use databend_common_expression::BlockEntry; use databend_common_expression::Column; use databend_common_expression::ColumnBuilder; +use databend_common_expression::ColumnView; use databend_common_expression::ProjectedBlock; use databend_common_expression::Scalar; use databend_common_expression::ScalarRef; @@ -85,20 +87,19 @@ where T: ArgType } } - fn add_batch(&mut self, column: &T::Column, validity: Option<&Bitmap>) -> Result<()> { - let column_len = T::column_len(column); + fn add_batch(&mut self, column: ColumnView, validity: Option<&Bitmap>) -> Result<()> { + let column_len = column.len(); if column_len == 0 { return Ok(()); } - let column_iter = T::iter_column(column); if let Some(validity) = validity { - for (val, valid) in column_iter.zip(validity.iter()) { + for (val, valid) in column.iter().zip(validity.iter()) { if valid { self.values.push(T::to_owned_scalar(val)); } } } else { - for val in column_iter { + for val in column.iter() { self.values.push(T::to_owned_scalar(val)); } } @@ -254,20 +255,29 @@ where fn accumulate( &self, place: AggrState, - columns: ProjectedBlock, + block: ProjectedBlock, _validity: Option<&Bitmap>, _input_rows: usize, ) -> Result<()> { let state = place.get::(); - match &columns[0].to_column() { - Column::Null { .. } => Ok(()), - Column::Nullable(box nullable_column) => { + + match &block[0] { + BlockEntry::Const(_, DataType::Null, _) + | BlockEntry::Column(Column::Null { .. }) + | BlockEntry::Const(Scalar::Null, DataType::Nullable(_), _) => Ok(()), + + entry @ BlockEntry::Const(_, DataType::Nullable(_), _) => { + let column = entry.clone().remove_nullable().downcast().unwrap(); + state.add_batch(column, None) + } + + BlockEntry::Column(Column::Nullable(box nullable_column)) => { let column = T::try_downcast_column(&nullable_column.column).unwrap(); - state.add_batch(&column, Some(&nullable_column.validity)) + state.add_batch(ColumnView::Column(column), Some(&nullable_column.validity)) } - _ => { - let column = T::try_downcast_column(&columns[0].to_column()).unwrap(); - state.add_batch(&column, None) + entry => { + let column = entry.downcast::().unwrap(); + state.add_batch(column, None) } } } @@ -276,56 +286,53 @@ where &self, places: &[StateAddr], loc: &[AggrStateLoc], - columns: ProjectedBlock, + block: ProjectedBlock, _input_rows: usize, ) -> Result<()> { - match &columns[0].to_column() { - Column::Null { .. } => (), - Column::Nullable(box nullable_column) => { - let column = T::try_downcast_column(&nullable_column.column).unwrap(); - let column_iter = T::iter_column(&column); - column_iter - .zip(nullable_column.validity.iter().zip(places.iter())) - .for_each(|(v, (valid, place))| { + let entry = &block[0]; + match entry.data_type() { + DataType::Null => {} + DataType::Nullable(_) => { + entry + .downcast::>() + .unwrap() + .iter() + .zip(places.iter()) + .for_each(|(v, place)| { let state = AggrState::new(*place, loc).get::(); - if valid { - state.add(Some(v.clone())) - } else { - state.add(None) - } + state.add(v) }); } _ => { - let column = T::try_downcast_column(&columns[0].to_column()).unwrap(); - let column_iter = T::iter_column(&column); - column_iter.zip(places.iter()).for_each(|(v, place)| { - let state = AggrState::new(*place, loc).get::(); - state.add(Some(v.clone())) - }); + entry + .downcast::() + .unwrap() + .iter() + .zip(places.iter()) + .for_each(|(v, place)| { + let state = AggrState::new(*place, loc).get::(); + state.add(Some(v)) + }); } } Ok(()) } - fn accumulate_row(&self, place: AggrState, columns: ProjectedBlock, row: usize) -> Result<()> { + fn accumulate_row(&self, place: AggrState, block: ProjectedBlock, row: usize) -> Result<()> { let state = place.get::(); - match &columns[0].to_column() { - Column::Null { .. } => (), - Column::Nullable(box nullable_column) => { - let valid = nullable_column.validity.get_bit(row); - if valid { - let column = T::try_downcast_column(&nullable_column.column).unwrap(); - let v = T::index_column(&column, row); - state.add(v); - } else { - state.add(None); - } + let entry = &block[0]; + match entry.data_type() { + DataType::Null => {} + DataType::Nullable(_) => { + let view = entry.downcast::>().unwrap(); + let v = view.index(row).unwrap(); + state.add(v); } _ => { - let column = T::try_downcast_column(&columns[0].to_column()).unwrap(); - let v = T::index_column(&column, row); - state.add(v); + let view = entry.downcast::().unwrap(); + let v = view.index(row).unwrap(); + state.add(Some(v)); } } diff --git a/src/query/functions/src/aggregates/aggregate_sum_zero.rs b/src/query/functions/src/aggregates/aggregate_sum_zero.rs index 012b1401d5644..0da923f8886f9 100644 --- a/src/query/functions/src/aggregates/aggregate_sum_zero.rs +++ b/src/query/functions/src/aggregates/aggregate_sum_zero.rs @@ -19,7 +19,6 @@ use std::sync::Arc; use databend_common_exception::ErrorCode; use databend_common_exception::Result; use databend_common_expression::types::number::NumberColumnBuilder; -use databend_common_expression::types::AccessType; use databend_common_expression::types::ArgType; use databend_common_expression::types::Bitmap; use databend_common_expression::types::DataType; @@ -109,17 +108,17 @@ impl AggregateFunction for AggregateSumZeroFunction { fn accumulate( &self, place: AggrState, - columns: ProjectedBlock, + block: ProjectedBlock, _validity: Option<&Bitmap>, _input_rows: usize, ) -> Result<()> { let state = place.get::(); - let column = columns[0].to_column(); - if column.is_nullable() { - let c = NullableType::::try_downcast_column(&column).unwrap(); + let entry = &block[0]; + if entry.data_type().is_nullable() { + let c = entry.downcast::>().unwrap(); c.iter().flatten().for_each(|v| state.sum += v); } else { - let c = UInt64Type::try_downcast_column(&column).unwrap(); + let c = entry.downcast::().unwrap(); let sum: u64 = c.iter().sum(); state.sum += sum; } @@ -130,13 +129,12 @@ impl AggregateFunction for AggregateSumZeroFunction { &self, places: &[StateAddr], loc: &[AggrStateLoc], - columns: ProjectedBlock, + block: ProjectedBlock, _input_rows: usize, ) -> Result<()> { - let column = columns[0].to_column(); - - if column.is_nullable() { - let c = NullableType::::try_downcast_column(&column).unwrap(); + let entry = &block[0]; + if entry.data_type().is_nullable() { + let c = entry.downcast::>().unwrap(); for (v, place) in c.iter().zip(places.iter()) { if let Some(v) = v { let state = AggrState::new(*place, loc).get::(); @@ -144,7 +142,7 @@ impl AggregateFunction for AggregateSumZeroFunction { } } } else { - let c = UInt64Type::try_downcast_column(&column).unwrap(); + let c = entry.downcast::().unwrap(); for (v, place) in c.iter().zip(places.iter()) { let state = AggrState::new(*place, loc).get::(); state.sum += v; @@ -153,17 +151,17 @@ impl AggregateFunction for AggregateSumZeroFunction { Ok(()) } - fn accumulate_row(&self, place: AggrState, columns: ProjectedBlock, row: usize) -> Result<()> { + fn accumulate_row(&self, place: AggrState, block: ProjectedBlock, row: usize) -> Result<()> { let state = place.get::(); - let c = columns[0].to_column(); - if c.is_nullable() { - let c = NullableType::::try_downcast_column(&c).unwrap(); + let entry = &block[0]; + if entry.data_type().is_nullable() { + let c = entry.downcast::>().unwrap(); if let Some(Some(v)) = c.index(row) { state.sum += v; } } else { - let c = UInt64Type::try_downcast_column(&c).unwrap(); - state.sum += c[row]; + let c = entry.downcast::().unwrap(); + state.sum += c.index(row).unwrap(); } Ok(()) } diff --git a/src/query/functions/src/aggregates/aggregator_common.rs b/src/query/functions/src/aggregates/aggregator_common.rs index cd1aa47d5d921..041d1250ec8db 100644 --- a/src/query/functions/src/aggregates/aggregator_common.rs +++ b/src/query/functions/src/aggregates/aggregator_common.rs @@ -172,29 +172,6 @@ pub fn eval_aggr( entries: &[BlockEntry], rows: usize, sort_descs: Vec, -) -> Result<(Column, DataType)> { - eval_aggr_inner(name, params, entries, rows, false, sort_descs) -} - -pub fn eval_aggr_for_test( - name: &str, - params: Vec, - entries: &[BlockEntry], - rows: usize, - with_serialize: bool, - sort_descs: Vec, -) -> Result<(Column, DataType)> { - eval_aggr_inner(name, params, entries, rows, with_serialize, sort_descs) -} - -#[inline] -fn eval_aggr_inner( - name: &str, - params: Vec, - entries: &[BlockEntry], - rows: usize, - with_serialize: bool, - sort_descs: Vec, ) -> Result<(Column, DataType)> { let factory = AggregateFunctionFactory::instance(); let arguments = entries.iter().map(BlockEntry::data_type).collect(); @@ -205,15 +182,6 @@ fn eval_aggr_inner( let eval = EvalAggr::new(func.clone()); let state = AggrState::new(eval.addr, &eval.state_layout.states_loc[0]); func.accumulate(state, entries.into(), None, rows)?; - if with_serialize { - let data_type = func.serialize_data_type(); - let mut builder = ColumnBuilder::with_capacity(&data_type, 1); - let builders = builder.as_tuple_mut().unwrap().as_mut_slice(); - func.batch_serialize(&[eval.addr], state.loc, builders)?; - func.init_state(state); - let column = builder.build(); - func.batch_merge(&[eval.addr], state.loc, &column.into(), None)?; - } let mut builder = ColumnBuilder::with_capacity(&data_type, 1024); func.merge_result(state, false, &mut builder)?; Ok((builder.build(), data_type)) diff --git a/src/query/functions/tests/it/aggregates/agg.rs b/src/query/functions/tests/it/aggregates/agg.rs index eb41a08d67a45..92b131bd2e7eb 100644 --- a/src/query/functions/tests/it/aggregates/agg.rs +++ b/src/query/functions/tests/it/aggregates/agg.rs @@ -22,17 +22,19 @@ use databend_common_expression::types::BooleanType; use databend_common_expression::types::DataType; use databend_common_expression::types::Decimal64Type; use databend_common_expression::types::DecimalSize; +use databend_common_expression::types::Int32Type; +use databend_common_expression::types::NullableType; use databend_common_expression::types::StringType; use databend_common_expression::types::TimestampType; use databend_common_expression::BlockEntry; use databend_common_expression::Column; use databend_common_expression::FromData; -use databend_common_functions::aggregates::eval_aggr_for_test; use databend_common_functions::aggregates::AggregateFunctionSortDesc; use databend_common_io::HybridBitmap; use goldenfile::Mint; use itertools::Itertools; +use super::eval_aggr_for_test; use super::run_agg_ast; use super::simulate_two_groups_group_by; use super::AggregationSimulator; @@ -40,12 +42,41 @@ use super::AggregationSimulator; fn eval_aggr( name: &str, params: Vec, - columns: &[Column], + entries: &[BlockEntry], rows: usize, sort_descs: Vec, ) -> Result<(Column, DataType)> { - let block_entries: Vec = columns.iter().map(|c| c.clone().into()).collect(); - eval_aggr_for_test(name, params, &block_entries, rows, true, sort_descs) + let res1 = eval_aggr_for_test( + name, + params.clone(), + entries, + rows, + false, + true, + sort_descs.clone(), + )?; + + let res2 = eval_aggr_for_test(name, params, entries, rows, true, true, sort_descs)?; + assert_eq!(res1, res2); + Ok(res1) +} + +fn eval_aggr_without_each_row( + name: &str, + params: Vec, + entries: &[BlockEntry], + rows: usize, + sort_descs: Vec, +) -> Result<(Column, DataType)> { + eval_aggr_for_test( + name, + params.clone(), + entries, + rows, + false, + true, + sort_descs.clone(), + ) } #[test] @@ -53,7 +84,8 @@ fn test_aggr_functions() { let mut mint = Mint::new("tests/it/aggregates/testdata"); let file = &mut mint.new_goldenfile("agg.txt").unwrap(); - test_count(file, eval_aggr); + // WARNING: AggregateCountFunction::accumulate_row do not check nulls + test_count(file, eval_aggr_without_each_row); test_count_distinct(file, eval_aggr); test_sum(file, eval_aggr); test_avg(file, eval_aggr); @@ -78,8 +110,8 @@ fn test_aggr_functions() { test_agg_quantile_tdigest(file, eval_aggr); // FIXME test_agg_quantile_tdigest_weighted(file, |name, params, columns, rows, _sort_descs| { - let block_entries: Vec = columns.iter().map(|c| c.clone().into()).collect(); - eval_aggr_for_test(name, params, &block_entries, rows, false, vec![]) + let block_entries = columns.to_vec(); + eval_aggr_for_test(name, params, &block_entries, rows, false, false, vec![]) }); test_agg_median(file, eval_aggr); test_agg_median_tdigest(file, eval_aggr); @@ -133,8 +165,8 @@ fn test_aggr_functions_group_by() { test_agg_list_agg(file, simulate_two_groups_group_by); test_agg_bitmap_count(file, simulate_two_groups_group_by); test_agg_bitmap(file, simulate_two_groups_group_by); - test_agg_group_array_moving_avg(file, eval_aggr); - test_agg_group_array_moving_sum(file, eval_aggr); + test_agg_group_array_moving_avg(file, simulate_two_groups_group_by); + test_agg_group_array_moving_sum(file, simulate_two_groups_group_by); test_agg_json_agg(file, eval_aggr); test_agg_json_array_agg(file, eval_aggr); test_agg_json_object_agg(file, eval_aggr); @@ -165,8 +197,8 @@ fn gen_bitmap_data() -> Column { BitmapType::from_data(rbs) } -fn get_example() -> Vec<(&'static str, Column)> { - vec![ +fn get_example() -> Vec<(&'static str, BlockEntry)> { + [ ("a", Int64Type::from_data(vec![4i64, 3, 2, 1])), ("b", UInt64Type::from_data(vec![1u64, 2, 3, 4])), ("c", UInt64Type::from_data(vec![1u64, 2, 1, 3])), @@ -227,10 +259,23 @@ fn get_example() -> Vec<(&'static str, Column)> { ]), ), ] + .into_iter() + .map(|(name, column)| (name, column.into())) + .chain([ + ( + "const_int", + BlockEntry::new_const_column_arg::(5, 4), + ), + ( + "const_int_null", + BlockEntry::new_const_column_arg::>(None, 4), + ), + ]) + .collect() } -fn get_geometry_example() -> Vec<(&'static str, Column)> { - vec![ +fn get_geometry_example() -> Vec<(&'static str, BlockEntry)> { + [ ( "point", StringType::from_data(vec!["POINT(1 1)", "POINT(2 2)", "POINT(3 3)", "POINT(4 4)"]), @@ -351,6 +396,9 @@ fn get_geometry_example() -> Vec<(&'static str, Column)> { ), ), ] + .into_iter() + .map(|(name, column)| (name, column.into())) + .collect() } fn test_count(file: &mut impl Write, simulator: impl AggregationSimulator) { @@ -361,6 +409,20 @@ fn test_count(file: &mut impl Write, simulator: impl AggregationSimulator) { simulator, vec![], ); + run_agg_ast( + file, + "count(const_int)", + get_example().as_slice(), + simulator, + vec![], + ); + run_agg_ast( + file, + "count(const_int_null)", + get_example().as_slice(), + simulator, + vec![], + ); run_agg_ast(file, "count()", get_example().as_slice(), simulator, vec![]); run_agg_ast( file, @@ -420,6 +482,20 @@ fn test_count_distinct(file: &mut impl Write, simulator: impl AggregationSimulat fn test_sum(file: &mut impl Write, simulator: impl AggregationSimulator) { run_agg_ast(file, "sum(1)", get_example().as_slice(), simulator, vec![]); run_agg_ast(file, "sum(a)", get_example().as_slice(), simulator, vec![]); + run_agg_ast( + file, + "sum(const_int)", + get_example().as_slice(), + simulator, + vec![], + ); + run_agg_ast( + file, + "sum(const_int_null)", + get_example().as_slice(), + simulator, + vec![], + ); run_agg_ast( file, "sum(x_null)", @@ -489,6 +565,13 @@ fn test_agg_if(file: &mut impl Write, simulator: impl AggregationSimulator) { simulator, vec![], ); + run_agg_ast( + file, + "count_if(1, false)", + get_example().as_slice(), + simulator, + vec![], + ); run_agg_ast( file, "sum_if(a, x_null is null)", @@ -572,6 +655,20 @@ fn test_agg_min(file: &mut impl Write, simulator: impl AggregationSimulator) { simulator, vec![], ); + run_agg_ast( + file, + "min(const_int)", + get_example().as_slice(), + simulator, + vec![], + ); + run_agg_ast( + file, + "min(const_int_null)", + get_example().as_slice(), + simulator, + vec![], + ); run_agg_ast(file, "min(a)", get_example().as_slice(), simulator, vec![]); run_agg_ast(file, "min(b)", get_example().as_slice(), simulator, vec![]); run_agg_ast( @@ -684,6 +781,34 @@ fn test_agg_arg_max(file: &mut impl Write, simulator: impl AggregationSimulator) simulator, vec![], ); + run_agg_ast( + file, + "arg_max(const_int, a)", + get_example().as_slice(), + simulator, + vec![], + ); + run_agg_ast( + file, + "arg_max(const_int_null, a)", + get_example().as_slice(), + simulator, + vec![], + ); + run_agg_ast( + file, + "arg_max(a, const_int)", + get_example().as_slice(), + simulator, + vec![], + ); + run_agg_ast( + file, + "arg_max(a, const_int_null)", + get_example().as_slice(), + simulator, + vec![], + ); run_agg_ast( file, "arg_max(y_null, a)", @@ -969,6 +1094,20 @@ fn test_agg_array_agg(file: &mut impl Write, simulator: impl AggregationSimulato simulator, vec![], ); + run_agg_ast( + file, + "array_agg(const_int)", + get_example().as_slice(), + simulator, + vec![], + ); + run_agg_ast( + file, + "array_agg(const_int_null)", + get_example().as_slice(), + simulator, + vec![], + ); run_agg_ast( file, "array_agg('a')", diff --git a/src/query/functions/tests/it/aggregates/agg_hashtable.rs b/src/query/functions/tests/it/aggregates/agg_hashtable.rs index 63266f2b5f38d..b838962d444ce 100644 --- a/src/query/functions/tests/it/aggregates/agg_hashtable.rs +++ b/src/query/functions/tests/it/aggregates/agg_hashtable.rs @@ -43,13 +43,13 @@ use databend_common_expression::types::Int16Type; use databend_common_expression::types::Int32Type; use databend_common_expression::types::Int64Type; use databend_common_expression::types::Int8Type; +use databend_common_expression::types::NullableType; use databend_common_expression::types::StringType; use databend_common_expression::types::UInt64Type; use databend_common_expression::types::F32; use databend_common_expression::types::F64; use databend_common_expression::AggregateHashTable; use databend_common_expression::BlockEntry; -use databend_common_expression::Column; use databend_common_expression::DataBlock; use databend_common_expression::FromData; use databend_common_expression::HashTableConfig; @@ -65,19 +65,22 @@ fn test_agg_hashtable() { let factory = AggregateFunctionFactory::instance(); let m: usize = 4; for n in [100, 1000, 10_000, 100_000] { - let columns = vec![ - StringType::from_data((0..n).map(|x| format!("{}", x % m)).collect_vec()), - Int64Type::from_data((0..n).map(|x| (x % m) as i64).collect_vec()), - Int32Type::from_data((0..n).map(|x| (x % m) as i32).collect_vec()), - Int16Type::from_data((0..n).map(|x| (x % m) as i16).collect_vec()), - Int8Type::from_data((0..n).map(|x| (x % m) as i8).collect_vec()), - Float32Type::from_data((0..n).map(|x| F32::from((x % m) as f32)).collect_vec()), - Float64Type::from_data((0..n).map(|x| F64::from((x % m) as f64)).collect_vec()), - BooleanType::from_data((0..n).map(|x| (x % m) != 0).collect_vec()), + let columns = [ + StringType::from_data((0..n).map(|x| format!("{}", x % m)).collect_vec()).into(), + Int64Type::from_data((0..n).map(|x| (x % m) as i64).collect_vec()).into(), + Int32Type::from_data((0..n).map(|x| (x % m) as i32).collect_vec()).into(), + Int16Type::from_data((0..n).map(|x| (x % m) as i16).collect_vec()).into(), + Int8Type::from_data((0..n).map(|x| (x % m) as i8).collect_vec()).into(), + Float32Type::from_data((0..n).map(|x| F32::from((x % m) as f32)).collect_vec()).into(), + Float64Type::from_data((0..n).map(|x| F64::from((x % m) as f64)).collect_vec()).into(), + BooleanType::from_data((0..n).map(|x| (x % m) != 0).collect_vec()).into(), + BlockEntry::new_const_column_arg::("a".to_string(), n), + BlockEntry::new_const_column_arg::>(None, n), + BlockEntry::new_const_column_arg::>(Some(4), n), ]; - let group_columns = columns.clone(); - let group_types: Vec<_> = group_columns.iter().map(|c| c.data_type()).collect(); + let group_columns = columns.to_vec(); + let group_types = columns.iter().map(|c| c.data_type()).collect::>(); let aggrs = vec![ factory @@ -94,10 +97,7 @@ fn test_agg_hashtable() { .unwrap(), ]; - let params: Vec> = aggrs - .iter() - .map(|_| vec![columns[1].clone().into()]) - .collect(); + let params = aggrs.iter().map(|_| vec![columns[1].clone()]).collect_vec(); let params = params.iter().map(|v| v.into()).collect_vec(); let config = HashTableConfig::default(); @@ -109,12 +109,10 @@ fn test_agg_hashtable() { ); let mut state = ProbeState::default(); - let group_block_entries: Vec = - group_columns.iter().map(|c| c.clone().into()).collect(); let _ = hashtable .add_groups( &mut state, - (&group_block_entries).into(), + (&group_columns).into(), ¶ms, (&[]).into(), n, @@ -128,13 +126,10 @@ fn test_agg_hashtable() { Arc::new(Bump::new()), ); - let mut state2 = ProbeState::default(); - let group_block_entries2: Vec = - group_columns.iter().map(|c| c.clone().into()).collect(); let _ = hashtable2 .add_groups( - &mut state2, - (&group_block_entries2).into(), + &mut state, + (&group_columns).into(), ¶ms, (&[]).into(), n, @@ -171,20 +166,23 @@ fn test_agg_hashtable() { let rows = n as i64; let urows = rows as u64; - let mut expected_results: Vec = - group_columns.iter().map(|c| c.slice(0..m)).collect(); + let mut expected_results = group_columns + .iter() + .map(|c| c.slice(0..m)) + .collect::>(); expected_results.extend_from_slice(&[ - Int64Type::from_data_with_validity(vec![0, 1, 2, 3], validities.clone()), - Int64Type::from_data_with_validity(vec![0, 1, 2, 3], validities.clone()), + Int64Type::from_data_with_validity(vec![0, 1, 2, 3], validities.clone()).into(), + Int64Type::from_data_with_validity(vec![0, 1, 2, 3], validities.clone()).into(), Int64Type::from_data_with_validity( vec![0, rows / 2, rows, rows / 2 * 3], validities.clone(), - ), - UInt64Type::from_data(vec![urows / 2, urows / 2, urows / 2, urows / 2]), + ) + .into(), + UInt64Type::from_data(vec![urows / 2, urows / 2, urows / 2, urows / 2]).into(), ]); - let block_expected = DataBlock::new_from_columns(expected_results.clone()); + let block_expected = DataBlock::new(expected_results.clone(), expected_results[0].len()); assert_block_value_sort_eq(&block, &block_expected); } } diff --git a/src/query/functions/tests/it/aggregates/mod.rs b/src/query/functions/tests/it/aggregates/mod.rs index 2cce2ff0c0ca1..adc0f885069f1 100644 --- a/src/query/functions/tests/it/aggregates/mod.rs +++ b/src/query/functions/tests/it/aggregates/mod.rs @@ -19,12 +19,14 @@ use std::io::Write; use bumpalo::Bump; use comfy_table::Table; +use databend_common_base::runtime::drop_guard; use databend_common_exception::Result; use databend_common_expression::get_states_layout; use databend_common_expression::type_check; use databend_common_expression::types::AnyType; use databend_common_expression::types::DataType; use databend_common_expression::AggrState; +use databend_common_expression::AggregateFunctionRef; use databend_common_expression::BlockEntry; use databend_common_expression::Column; use databend_common_expression::ColumnBuilder; @@ -33,6 +35,8 @@ use databend_common_expression::Evaluator; use databend_common_expression::FunctionContext; use databend_common_expression::RawExpr; use databend_common_expression::Scalar; +use databend_common_expression::StateAddr; +use databend_common_expression::StatesLayout; use databend_common_expression::Value; use databend_common_functions::aggregates::AggregateFunctionFactory; use databend_common_functions::aggregates::AggregateFunctionSortDesc; @@ -44,7 +48,7 @@ use super::scalars::parser; pub trait AggregationSimulator = Fn( &str, Vec, - &[Column], + &[BlockEntry], usize, Vec, ) -> databend_common_exception::Result<(Column, DataType)> @@ -54,21 +58,25 @@ pub trait AggregationSimulator = Fn( pub fn run_agg_ast( file: &mut impl Write, text: &str, - columns: &[(&str, Column)], + entries: &[(&str, BlockEntry)], simulator: impl AggregationSimulator, sort_descs: Vec, ) { let raw_expr = parser::parse_raw_expr( text, - &columns + &entries .iter() - .map(|(name, col)| (*name, col.data_type())) + .map(|(name, entry)| (*name, entry.data_type())) .collect::>(), ); - let num_rows = columns.iter().map(|col| col.1.len()).max().unwrap_or(0); + let num_rows = entries + .iter() + .map(|(_, entry)| entry.len()) + .max() + .unwrap_or(0); let block = DataBlock::new( - columns.iter().map(|(_, col)| col.clone().into()).collect(), + entries.iter().map(|(_, entry)| entry.clone()).collect(), num_rows, ); @@ -79,89 +87,112 @@ pub fn run_agg_ast( .sorted() .collect::>(); - // For test only, we just support agg function call here - let result: databend_common_exception::Result<(Column, DataType)> = try { - match raw_expr { - databend_common_expression::RawExpr::FunctionCall { - name, params, args, .. - } => { - let args: Vec<(Value, DataType)> = args - .iter() - .map(|raw_expr| run_scalar_expr(raw_expr, &block)) - .collect::>() - .unwrap(); - - // Convert the delimiter of string_agg to params - let params = if name.eq_ignore_ascii_case("string_agg") && args.len() == 2 { - let val = args[1].0.as_scalar().unwrap(); - vec![val.clone()] - } else { - params - }; + let args: databend_common_exception::Result<_> = try { + // For test only, we just support agg function call here + let databend_common_expression::RawExpr::FunctionCall { + name, params, args, .. + } = raw_expr + else { + unimplemented!() + }; - // Convert the num_buckets of histogram to params - let params = if name.eq_ignore_ascii_case("histogram") && args.len() == 2 { - let val = args[1].0.as_scalar().unwrap(); - vec![val.clone()] - } else { - params - }; - - let arg_columns: Vec = args - .iter() - .map(|(arg, ty)| match arg { - Value::Scalar(s) => { - let builder = ColumnBuilder::repeat(&s.as_ref(), block.num_rows(), ty); - builder.build() - } - Value::Column(c) => c.clone(), - }) - .collect(); - - simulator( - name.as_str(), - params, - &arg_columns, - block.num_rows(), - sort_descs, - )? - } - _ => unimplemented!(), + let args: Vec<(Value, DataType)> = args + .iter() + .map(|raw_expr| run_scalar_expr(raw_expr, &block)) + .collect::>() + .unwrap(); + + // Convert the delimiter of string_agg to params + let params = if name.eq_ignore_ascii_case("string_agg") && args.len() == 2 { + let val = args[1].0.as_scalar().unwrap(); + vec![val.clone()] + } else { + params + }; + + // Convert the num_buckets of histogram to params + let params = if name.eq_ignore_ascii_case("histogram") && args.len() == 2 { + let val = args[1].0.as_scalar().unwrap(); + vec![val.clone()] + } else { + params + }; + + let arg_columns = args + .into_iter() + .map(|(arg, ty)| BlockEntry::new(arg, || (ty, block.num_rows()))) + .collect::>(); + + (name, params, arg_columns) + }; + + let (name, params, arg_columns) = match args { + Ok(x) => x, + Err(e) => { + writeln!(file, "error: {}\n", e.message()).unwrap(); + return; } }; - match result { - Ok((column, _)) => { - writeln!(file, "ast: {text}").unwrap(); - { - let mut table = Table::new(); - table.load_preset("||--+-++| ++++++"); - table.set_header(["Column", "Data"]); - - let ids = match used_columns.is_empty() { - true => { - if columns.is_empty() { - vec![] - } else { - vec![0] - } - } - false => used_columns, - }; - - for id in ids.iter() { - let (name, col) = &columns[*id]; - table.add_row(&[name.to_string(), format!("{col:?}")]); - } - table.add_row(["Output".to_string(), format!("{column:?}")]); - writeln!(file, "evaluation (internal):\n{table}").unwrap(); - } - write!(file, "\n\n").unwrap(); + let column = match simulator( + name.as_str(), + params.clone(), + &arg_columns, + block.num_rows(), + sort_descs.clone(), + ) { + Ok((column, _)) => column, + Err(e) => { + writeln!(file, "error: {}\n", e.message()).unwrap(); + return; + } + }; + + let arg_columns_full = arg_columns + .into_iter() + .map(|entry| entry.to_column().into()) + .collect::>(); + match simulator( + name.as_str(), + params.clone(), + &arg_columns_full, + block.num_rows(), + sort_descs.clone(), + ) { + Ok((column2, _)) => { + assert_eq!(column, column2) } Err(e) => { writeln!(file, "error: {}\n", e.message()).unwrap(); + return; } + }; + + writeln!(file, "ast: {text}").unwrap(); + { + let mut table = Table::new(); + table.load_preset("||--+-++| ++++++"); + table.set_header(["Column", "Data"]); + + let ids = match used_columns.is_empty() { + true => { + if entries.is_empty() { + vec![] + } else { + vec![0] + } + } + false => used_columns, + }; + + for id in ids.iter() { + let (name, entry) = &entries[*id]; + table.add_row(&[name.to_string(), format!("{entry:?}")]); + } + table.add_row(["Output".to_string(), format!("{column:?}")]); + writeln!(file, "evaluation (internal):\n{table}").unwrap(); } + write!(file, "\n\n").unwrap(); } pub fn run_scalar_expr( @@ -195,12 +226,12 @@ pub fn run_scalar_expr( pub fn simulate_two_groups_group_by( name: &str, params: Vec, - columns: &[Column], + entries: &[BlockEntry], rows: usize, sort_descs: Vec, ) -> databend_common_exception::Result<(Column, DataType)> { let factory = AggregateFunctionFactory::instance(); - let arguments: Vec = columns.iter().map(|c| c.data_type()).collect(); + let arguments: Vec = entries.iter().map(|c| c.data_type()).collect(); let func = factory.get(name, params, arguments, sort_descs)?; let data_type = func.return_type()?; @@ -221,8 +252,7 @@ pub fn simulate_two_groups_group_by( .map(|i| if i % 2 == 0 { addr1 } else { addr2 }) .collect::>(); - let block_entries: Vec = columns.iter().map(|c| c.clone().into()).collect(); - func.accumulate_keys(&places, &loc, (&block_entries).into(), rows)?; + func.accumulate_keys(&places, &loc, entries.into(), rows)?; let mut builder = ColumnBuilder::with_capacity(&data_type, 1024); func.merge_result(state1, false, &mut builder)?; @@ -230,3 +260,84 @@ pub fn simulate_two_groups_group_by( Ok((builder.build(), data_type)) } + +pub fn eval_aggr_for_test( + name: &str, + params: Vec, + entries: &[BlockEntry], + rows: usize, + each_row: bool, + with_serialize: bool, + sort_descs: Vec, +) -> Result<(Column, DataType)> { + let factory = AggregateFunctionFactory::instance(); + let arguments = entries.iter().map(BlockEntry::data_type).collect(); + + let func = factory.get(name, params, arguments, sort_descs)?; + let data_type = func.return_type()?; + + let eval = EvalAggr::new(func.clone()); + let state = AggrState::new(eval.addr, &eval.state_layout.states_loc[0]); + + if each_row { + for row in 0..rows { + func.accumulate_row(state, entries.into(), row)?; + } + } else { + func.accumulate(state, entries.into(), None, rows)?; + } + + if with_serialize { + let data_type = func.serialize_data_type(); + let mut builder = ColumnBuilder::with_capacity(&data_type, 1); + let builders = builder.as_tuple_mut().unwrap().as_mut_slice(); + func.batch_serialize(&[eval.addr], state.loc, builders)?; + func.init_state(state); + let column = builder.build(); + func.batch_merge(&[eval.addr], state.loc, &column.into(), None)?; + } + let mut builder = ColumnBuilder::with_capacity(&data_type, 1024); + func.merge_result(state, false, &mut builder)?; + Ok((builder.build(), data_type)) +} + +struct EvalAggr { + addr: StateAddr, + state_layout: StatesLayout, + _arena: Bump, + func: AggregateFunctionRef, +} + +impl EvalAggr { + pub fn new(func: AggregateFunctionRef) -> Self { + let funcs = [func]; + let state_layout = get_states_layout(&funcs).unwrap(); + let [func] = funcs; + + let _arena = Bump::new(); + let addr = _arena.alloc_layout(state_layout.layout).into(); + + let state = AggrState::new(addr, &state_layout.states_loc[0]); + func.init_state(state); + + Self { + addr, + state_layout, + _arena, + func, + } + } +} + +impl Drop for EvalAggr { + fn drop(&mut self) { + drop_guard(move || { + if self.func.need_manual_drop_state() { + unsafe { + self.func + .drop_state(AggrState::new(self.addr, &self.state_layout.states_loc[0])); + } + } + }) + } +} diff --git a/src/query/functions/tests/it/aggregates/testdata/agg.txt b/src/query/functions/tests/it/aggregates/testdata/agg.txt index 39286dd315032..5bc308e3f32b2 100644 --- a/src/query/functions/tests/it/aggregates/testdata/agg.txt +++ b/src/query/functions/tests/it/aggregates/testdata/agg.txt @@ -1,154 +1,174 @@ ast: count(1) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([4]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([4]) | ++--------+-----------------------------+ + + +ast: count(const_int) +evaluation (internal): ++-----------+----------------------------------------+ +| Column | Data | ++-----------+----------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | UInt64([4]) | ++-----------+----------------------------------------+ + + +ast: count(const_int_null) +evaluation (internal): ++----------------+-----------------------------------------+ +| Column | Data | ++----------------+-----------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | UInt64([0]) | ++----------------+-----------------------------------------+ ast: count() evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([4]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([4]) | ++--------+-----------------------------+ ast: count(a) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([4]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([4]) | ++--------+-----------------------------+ ast: count(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([2]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([2]) | ++--------+---------------------------------------------------------------------------------+ ast: sum0(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([3]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([3]) | ++--------+---------------------------------------------------------------------------------+ ast: count(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | UInt64([0]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | UInt64([0]) | ++----------+---------------------------------------------------------------------------------+ ast: count_distinct(null) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([0]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0]) | ++--------+-----------------------------+ ast: count_distinct(null,null) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([0]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0]) | ++--------+-----------------------------+ ast: count_distinct(1) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([1]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([1]) | ++--------+-----------------------------+ ast: count_distinct(a) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([4]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([4]) | ++--------+-----------------------------+ ast: count_distinct(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([2]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([2]) | ++--------+---------------------------------------------------------------------------------+ ast: count_distinct(x_null,a) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([4]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([4]) | ++--------+---------------------------------------------------------------------------------+ ast: count_distinct(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | UInt64([0]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | UInt64([0]) | ++----------+---------------------------------------------------------------------------------+ ast: count_distinct(all_null,s) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| s | StringColumn[abc, def, opq, xyz] | -| Output | UInt64([4]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| s | Column(StringColumn[abc, def, opq, xyz]) | +| Output | UInt64([4]) | ++----------+---------------------------------------------------------------------------------+ ast: count_distinct(s_null,s) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | UInt64([4]) | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s | Column(StringColumn[abc, def, opq, xyz]) | +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | UInt64([4]) | ++--------+------------------------------------------------------------------------------------+ ast: sum(1) @@ -156,7 +176,7 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ @@ -166,29 +186,49 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([10]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ +ast: sum(const_int) +evaluation (internal): ++-----------+----------------------------------------------------------------+ +| Column | Data | ++-----------+----------------------------------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int64([20]), validity: [0b_______1] } | ++-----------+----------------------------------------------------------------+ + + +ast: sum(const_int_null) +evaluation (internal): ++----------------+---------------------------------------------------------------+ +| Column | Data | ++----------------+---------------------------------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int64([0]), validity: [0b_______0] } | ++----------------+---------------------------------------------------------------+ + + ast: sum(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: sum(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: avg(1) @@ -196,7 +236,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([1]), validity: [0b_______1] } | +--------+-----------------------------------------------------------------+ @@ -206,111 +246,121 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([2.5]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------+ ast: avg(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | NullableColumn { column: Decimal64([2.2000]), validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | NullableColumn { column: Decimal64([2.2000]), validity: [0b_______1] } | ++--------+------------------------------------------------------------------------------------------------+ ast: avg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1.5]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1.5]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: avg(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Float64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Float64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: uniq(1) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([1]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([1]) | ++--------+-----------------------------+ ast: uniq(c) evaluation (internal): -+--------+----------------------+ -| Column | Data | -+--------+----------------------+ -| c | UInt64([1, 2, 1, 3]) | -| Output | UInt64([3]) | -+--------+----------------------+ ++--------+------------------------------+ +| Column | Data | ++--------+------------------------------+ +| c | Column(UInt64([1, 2, 1, 3])) | +| Output | UInt64([3]) | ++--------+------------------------------+ ast: uniq(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([2]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([2]) | ++--------+---------------------------------------------------------------------------------+ ast: uniq(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | UInt64([0]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | UInt64([0]) | ++----------+---------------------------------------------------------------------------------+ ast: count_if(1, x_null is null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([2]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([2]) | ++--------+---------------------------------------------------------------------------------+ + + +ast: count_if(1, false) +evaluation (internal): ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0]) | ++--------+-----------------------------+ ast: sum_if(a, x_null is null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Int64([3]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Int64([3]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: sum_if(b, x_null is null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([7]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([7]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: sum_distinct(a) @@ -318,7 +368,7 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([10]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ @@ -328,29 +378,29 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| c | UInt64([1, 2, 1, 3]) | +| c | Column(UInt64([1, 2, 1, 3])) | | Output | NullableColumn { column: UInt64([6]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ ast: sum_distinct(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: sum_distinct(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: max(1) @@ -358,19 +408,19 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ ast: max(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 1 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 1 } | ++--------+-----------------------------+ ast: max(a) @@ -378,7 +428,7 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([4]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ @@ -388,29 +438,29 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ ast: max(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([2]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([2]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: max(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: min(1) @@ -418,19 +468,39 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ ast: min(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 1 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 1 } | ++--------+-----------------------------+ + + +ast: min(const_int) +evaluation (internal): ++-----------+---------------------------------------------------------------+ +| Column | Data | ++-----------+---------------------------------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int32([5]), validity: [0b_______1] } | ++-----------+---------------------------------------------------------------+ + + +ast: min(const_int_null) +evaluation (internal): ++----------------+---------------------------------------------------------------+ +| Column | Data | ++----------------+---------------------------------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int32([0]), validity: [0b_______0] } | ++----------------+---------------------------------------------------------------+ ast: min(a) @@ -438,7 +508,7 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([1]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ @@ -448,29 +518,29 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ ast: min(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: min(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: any(1) @@ -478,19 +548,19 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ ast: any(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 1 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 1 } | ++--------+-----------------------------+ ast: any(a) @@ -498,7 +568,7 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([4]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ @@ -508,39 +578,39 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ ast: any(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: any(y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: any(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_min(a, b) @@ -548,8 +618,8 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Int64([4]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ @@ -559,54 +629,54 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ ast: arg_min(y_null, a) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_min(a, y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: Int64([2]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: Int64([2]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_min(all_null, a) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_min(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Int64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Int64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_max(a, b) @@ -614,8 +684,8 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Int64([1]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ @@ -625,54 +695,98 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ +ast: arg_max(const_int, a) +evaluation (internal): ++-----------+---------------------------------------------------------------+ +| Column | Data | ++-----------+---------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int32([5]), validity: [0b_______1] } | ++-----------+---------------------------------------------------------------+ + + +ast: arg_max(const_int_null, a) +evaluation (internal): ++----------------+---------------------------------------------------------------+ +| Column | Data | ++----------------+---------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int32([0]), validity: [0b_______0] } | ++----------------+---------------------------------------------------------------+ + + +ast: arg_max(a, const_int) +evaluation (internal): ++-----------+---------------------------------------------------------------+ +| Column | Data | ++-----------+---------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int64([4]), validity: [0b_______1] } | ++-----------+---------------------------------------------------------------+ + + +ast: arg_max(a, const_int_null) +evaluation (internal): ++----------------+---------------------------------------------------------------+ +| Column | Data | ++----------------+---------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int64([0]), validity: [0b_______0] } | ++----------------+---------------------------------------------------------------+ + + ast: arg_max(y_null, a) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: UInt64([3]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_max(a, y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: Int64([1]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: Int64([1]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_max(all_null, a) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_max(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Int64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Int64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: covar_samp(a, b) @@ -680,32 +794,32 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Float64([-1.6666666666]), validity: [0b_______1] } | +--------+-----------------------------------------------------------------------------+ ast: covar_samp(a, x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([-0.5]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([-0.5]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: covar_samp(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Float64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Float64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: covar_pop(a, b) @@ -713,32 +827,32 @@ evaluation (internal): +--------+---------------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Float64([-1.25]), validity: [0b_______1] } | +--------+---------------------------------------------------------------------+ ast: covar_pop(a, x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([-0.25]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([-0.25]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: covar_pop(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Float64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Float64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: retention(a > 1, b > 1) @@ -746,8 +860,8 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: ArrayColumn { values: UInt8([1, 1]), offsets: [0, 2] }, validity: [0b_______1] } | +--------+-----------------------------------------------------------------------------------------------------------+ @@ -757,9 +871,9 @@ evaluation (internal): +--------+--------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | | Output | NullableColumn { column: ArrayColumn { values: UInt8([1, 1, 1]), offsets: [0, 3] }, validity: [0b_______1] } | +--------+--------------------------------------------------------------------------------------------------------------+ @@ -769,10 +883,10 @@ evaluation (internal): +----------+-------------------------------------------------------------------------------------------------------+ | Column | Data | +----------+-------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | | Output | NullableColumn { column: ArrayColumn { values: UInt8([]), offsets: [0, 0] }, validity: [0b_______0] } | +----------+-------------------------------------------------------------------------------------------------------+ @@ -782,19 +896,19 @@ evaluation (internal): +--------+----------------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([1.1180339887]), validity: [0b_______1] } | +--------+----------------------------------------------------------------------------+ ast: stddev(x_null) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0.7071067811]), validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0.7071067811]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: stddev_samp(a) @@ -802,29 +916,29 @@ evaluation (internal): +--------+----------------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([1.2909944487]), validity: [0b_______1] } | +--------+----------------------------------------------------------------------------+ ast: stddev_samp(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | NullableColumn { column: Float64([1.1]), validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | NullableColumn { column: Float64([1.1]), validity: [0b_______1] } | ++--------+------------------------------------------------------------------------------------------------+ ast: stddev_samp(x_null) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0.7071067811]), validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0.7071067811]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: kurtosis(a) @@ -832,19 +946,19 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([-1.2]), validity: [0b_______1] } | +--------+--------------------------------------------------------------------+ ast: kurtosis(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: skewness(a) @@ -852,19 +966,19 @@ evaluation (internal): +--------+-----------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +--------+-----------------------------------------------------------------+ ast: skewness(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: window_funnel(2)(dt, event1, event2, event3) @@ -872,42 +986,42 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| dt | Timestamp([1, 0, 2, 3]) | -| event1 | Boolean([0b____0001]) | -| event2 | Boolean([0b____0000]) | -| event3 | Boolean([0b____0000]) | +| dt | Column(Timestamp([1, 0, 2, 3])) | +| event1 | Column(Boolean([0b____0001])) | +| event2 | Column(Boolean([0b____0000])) | +| event3 | Column(Boolean([0b____0000])) | | Output | NullableColumn { column: UInt8([1]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ ast: approx_count_distinct(a) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([4]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([4]) | ++--------+-----------------------------+ ast: approx_count_distinct(b) evaluation (internal): -+--------+----------------------+ -| Column | Data | -+--------+----------------------+ -| b | UInt64([1, 2, 3, 4]) | -| Output | UInt64([4]) | -+--------+----------------------+ ++--------+------------------------------+ +| Column | Data | ++--------+------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| Output | UInt64([4]) | ++--------+------------------------------+ ast: approx_count_distinct(null) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([0]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0]) | ++--------+-----------------------------+ ast: quantile_cont(0.8)(a) @@ -915,19 +1029,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([3.4]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------+ ast: quantile_cont(0.8)(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1.8]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1.8]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: quantile_cont(0.8)(a) @@ -935,19 +1049,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([3.4]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------+ ast: quantile_cont(0.8)(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1.8]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1.8]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: quantile_tdigest(0.8)(a) @@ -955,19 +1069,19 @@ evaluation (internal): +--------+-----------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([4]), validity: [0b_______1] } | +--------+-----------------------------------------------------------------+ ast: quantile_tdigest(0.8)(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([2]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([2]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: quantile_tdigest_weighted(0.8)(a, b) @@ -975,21 +1089,21 @@ evaluation (internal): +--------+-----------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Float64([4]), validity: [0b_______1] } | +--------+-----------------------------------------------------------------+ ast: quantile_tdigest_weighted(0.8)(x_null, b) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([2]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([2]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: median(a) @@ -997,19 +1111,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([2.5]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------+ ast: median(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1.5]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1.5]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: median_tdigest(a) @@ -1017,19 +1131,19 @@ evaluation (internal): +--------+-----------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([3]), validity: [0b_______1] } | +--------+-----------------------------------------------------------------+ ast: median_tdigest(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([2]), validity: [0b_______1] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([2]), validity: [0b_______1] } | ++--------+---------------------------------------------------------------------------------+ ast: array_agg(1) @@ -1037,17 +1151,37 @@ evaluation (internal): +--------+--------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: UInt8([1, 1, 1, 1]), offsets: [0, 4] } | +--------+--------------------------------------------------------------+ +ast: array_agg(const_int) +evaluation (internal): ++-----------+--------------------------------------------------------------+ +| Column | Data | ++-----------+--------------------------------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | ArrayColumn { values: Int32([5, 5, 5, 5]), offsets: [0, 4] } | ++-----------+--------------------------------------------------------------+ + + +ast: array_agg(const_int_null) +evaluation (internal): ++----------------+----------------------------------------------------+ +| Column | Data | ++----------------+----------------------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | ArrayColumn { values: Int32([]), offsets: [0, 0] } | ++----------------+----------------------------------------------------+ + + ast: array_agg('a') evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: StringColumn[a, a, a, a], offsets: [0, 4] } | +--------+-------------------------------------------------------------------+ @@ -1057,7 +1191,7 @@ evaluation (internal): +--------+----------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Null { len: 0 }, offsets: [0, 0] } | +--------+----------------------------------------------------------+ @@ -1067,7 +1201,7 @@ evaluation (internal): +--------+--------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Int64([4, 3, 2, 1]), offsets: [0, 4] } | +--------+--------------------------------------------------------------+ @@ -1077,29 +1211,29 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | ArrayColumn { values: UInt64([1, 2, 3, 4]), offsets: [0, 4] } | +--------+---------------------------------------------------------------+ ast: array_agg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | ArrayColumn { values: UInt64([1, 2]), offsets: [0, 2] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | ArrayColumn { values: UInt64([1, 2]), offsets: [0, 2] } | ++--------+---------------------------------------------------------------------------------+ ast: array_agg(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | ArrayColumn { values: UInt64([]), offsets: [0, 0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | ArrayColumn { values: UInt64([]), offsets: [0, 0] } | ++----------+---------------------------------------------------------------------------------+ ast: array_agg(dt) @@ -1107,7 +1241,7 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| dt | Timestamp([1, 0, 2, 3]) | +| dt | Column(Timestamp([1, 0, 2, 3])) | | Output | ArrayColumn { values: Timestamp([1, 0, 2, 3]), offsets: [0, 4] } | +--------+------------------------------------------------------------------+ @@ -1117,19 +1251,19 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| event1 | Boolean([0b____0001]) | +| event1 | Column(Boolean([0b____0001])) | | Output | ArrayColumn { values: Boolean([0b____0001]), offsets: [0, 4] } | +--------+----------------------------------------------------------------+ ast: array_agg(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([1.10, 2.20, 3.30]), offsets: [0, 3] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([1.10, 2.20, 3.30]), offsets: [0, 3] } | ++--------+------------------------------------------------------------------------------------------------+ ast: array_agg(s) @@ -1137,7 +1271,7 @@ evaluation (internal): +--------+---------------------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | ArrayColumn { values: StringColumn[abc, def, opq, xyz], offsets: [0, 4] } | +--------+---------------------------------------------------------------------------+ @@ -1147,7 +1281,7 @@ evaluation (internal): +--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| json | StringColumn[{"k1":"v1","k2":"v2"}, [1,2,3,"abc"], 99999, "xyz"] | +| json | Column(StringColumn[{"k1":"v1","k2":"v2"}, [1,2,3,"abc"], 99999, "xyz"]) | | Output | ArrayColumn { values: Variant([0x40000002100000021000000210000002100000026b316b3276317632, 0x8000000420000002200000022000000210000003500150025003616263, 0x2000000020000005500001869f, 0x200000001000000378797a]), offsets: [0, 4] } | +--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1157,19 +1291,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abcdefopqxyz], validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------+ ast: string_agg(s_null) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[acd], validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[acd], validity: [0b_______1] } | ++--------+------------------------------------------------------------------------------------+ ast: string_agg(s, '|') @@ -1177,19 +1311,19 @@ evaluation (internal): +--------+----------------------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abc|def|opq|xyz], validity: [0b_______1] } | +--------+----------------------------------------------------------------------------------+ ast: string_agg(s_null, '-') evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[a-c-d], validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[a-c-d], validity: [0b_______1] } | ++--------+------------------------------------------------------------------------------------+ ast: listagg(s) @@ -1197,19 +1331,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abcdefopqxyz], validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------+ ast: listagg(s_null) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[acd], validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[acd], validity: [0b_______1] } | ++--------+------------------------------------------------------------------------------------+ ast: listagg(s, '|') @@ -1217,101 +1351,101 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abcdefopqxyz], validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------+ ast: listagg(s_null, '-') evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[acd], validity: [0b_______1] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[acd], validity: [0b_______1] } | ++--------+------------------------------------------------------------------------------------+ ast: bitmap_and_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([2]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([2]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_or_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([8]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([8]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_xor_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_not_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: intersect_count(1, 2, 3, 4)(bm, b) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([2]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([2]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: intersect_count(1, 2)(bm, b) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([4]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_union(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: Bitmap([0x484201000800000000000000000100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000000700000000000000]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: Bitmap([0x484201000800000000000000000100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000000700000000000000]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_intersect(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: Bitmap([0x484201000203000000000000000400000000000000]), validity: [0b_______1] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: Bitmap([0x484201000203000000000000000400000000000000]), validity: [0b_______1] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: group_array_moving_avg(1) @@ -1319,7 +1453,7 @@ evaluation (internal): +--------+------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Float64([0.25, 0.5, 0.75, 1]), offsets: [0, 4] } | +--------+------------------------------------------------------------------------+ @@ -1331,7 +1465,7 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Float64([0, 0, 0, 0]), offsets: [0, 4] } | +--------+----------------------------------------------------------------+ @@ -1341,7 +1475,7 @@ evaluation (internal): +--------+------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Float64([1, 1.75, 2.25, 2.5]), offsets: [0, 4] } | +--------+------------------------------------------------------------------------+ @@ -1351,49 +1485,49 @@ evaluation (internal): +--------+------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | ArrayColumn { values: Float64([0.5, 1.5, 2.5, 3.5]), offsets: [0, 4] } | +--------+------------------------------------------------------------------------+ ast: group_array_moving_avg(x_null) evaluation (internal): -+--------+--------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | ArrayColumn { values: Float64([0.25, 0.75, 1.5, 2.5]), offsets: [0, 4] } | -+--------+--------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | ArrayColumn { values: Float64([0.25, 0.75, 0.75, 0.75]), offsets: [0, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_avg(1)(y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | ArrayColumn { values: Float64([1, 2, 3, 4]), offsets: [0, 4] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | ArrayColumn { values: Float64([0, 0, 3, 4]), offsets: [0, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_avg(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([0.2750, 0.8250, 0.8250, 1.6500]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([0.2750, 0.8250, 0.8250, 1.6500]), offsets: [0, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: group_array_moving_avg(2)(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([0.5500, 1.6500, 1.1000, 1.6500]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([0.5500, 1.6500, 1.1000, 1.6500]), offsets: [0, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: group_array_moving_sum(1) @@ -1401,7 +1535,7 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: UInt64([1, 2, 3, 4]), offsets: [0, 4] } | +--------+---------------------------------------------------------------+ @@ -1413,7 +1547,7 @@ evaluation (internal): +--------+--------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Int64([0, 0, 0, 0]), offsets: [0, 4] } | +--------+--------------------------------------------------------------+ @@ -1423,7 +1557,7 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Int64([4, 7, 9, 10]), offsets: [0, 4] } | +--------+---------------------------------------------------------------+ @@ -1433,59 +1567,59 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | ArrayColumn { values: UInt64([1, 3, 5, 7]), offsets: [0, 4] } | +--------+---------------------------------------------------------------+ ast: group_array_moving_sum(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | ArrayColumn { values: UInt64([1, 3, 6, 10]), offsets: [0, 4] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | ArrayColumn { values: UInt64([1, 3, 3, 3]), offsets: [0, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_sum(1)(y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | ArrayColumn { values: UInt64([1, 2, 3, 4]), offsets: [0, 4] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | ArrayColumn { values: UInt64([0, 0, 3, 4]), offsets: [0, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_sum(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([1.10, 3.30, 3.30, 6.60]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([1.10, 3.30, 3.30, 6.60]), offsets: [0, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: group_array_moving_sum(2)(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([1.10, 3.30, 2.20, 3.30]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([1.10, 3.30, 2.20, 3.30]), offsets: [0, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: histogram(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: StringColumn[], validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: StringColumn[], validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: histogram(x_null) @@ -1493,7 +1627,7 @@ evaluation (internal): +--------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | | Output | NullableColumn { column: StringColumn[[{"lower":"1","upper":"1","ndv":1,"count":1,"pre_sum":0},{"lower":"2","upper":"2","ndv":1,"count":1,"pre_sum":1}]], validity: [0b_______1] } | +--------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1503,7 +1637,7 @@ evaluation (internal): +--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: StringColumn[[{"lower":"1","upper":"1","ndv":1,"count":1,"pre_sum":0},{"lower":"2","upper":"2","ndv":1,"count":1,"pre_sum":1},{"lower":"3","upper":"3","ndv":1,"count":1,"pre_sum":2},{"lower":"4","upper":"4","ndv":1,"count":1,"pre_sum":3}]], validity: [0b_______1] } | +--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1513,7 +1647,7 @@ evaluation (internal): +--------+----------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: StringColumn[[{"lower":"1","upper":"4","ndv":4,"count":4,"pre_sum":0}]], validity: [0b_______1] } | +--------+----------------------------------------------------------------------------------------------------------------------------+ @@ -1523,19 +1657,19 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x80000004200000022000000220000002200000024004400340024001]) | +--------+-----------------------------------------------------------------------+ ast: json_agg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | Variant([0x80000002200000022000000250015002]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | Variant([0x80000002200000022000000250015002]) | ++--------+---------------------------------------------------------------------------------+ ast: json_agg(dec) @@ -1543,7 +1677,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | | Output | Variant([0x800000032000000a2000000a2000000a70000000000000006e027000000000000000dc0270000000000000014a02]) | +--------+-----------------------------------------------------------------------------------------------------------+ @@ -1553,7 +1687,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x80000004200000022000000220000002200000025001500150015001]) | +--------+-----------------------------------------------------------------------+ @@ -1563,19 +1697,19 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x800000041000000110000001100000011000000161616161]) | +--------+---------------------------------------------------------------+ ast: json_array_agg(NULL) evaluation (internal): -+--------+-----------------------+ -| Column | Data | -+--------+-----------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Variant([0x80000000]) | -+--------+-----------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Variant([0x80000000]) | ++--------+-----------------------------+ ast: json_array_agg(a) @@ -1583,7 +1717,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x80000004200000022000000220000002200000024004400340024001]) | +--------+-----------------------------------------------------------------------+ @@ -1593,29 +1727,29 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | Variant([0x80000004200000022000000220000002200000025001500250035004]) | +--------+-----------------------------------------------------------------------+ ast: json_array_agg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | Variant([0x80000002200000022000000250015002]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | Variant([0x80000002200000022000000250015002]) | ++--------+---------------------------------------------------------------------------------+ ast: json_array_agg(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | Variant([0x80000000]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | Variant([0x80000000]) | ++----------+---------------------------------------------------------------------------------+ ast: json_array_agg(dt) @@ -1623,7 +1757,7 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------+ -| dt | Timestamp([1, 0, 2, 3]) | +| dt | Column(Timestamp([1, 0, 2, 3])) | | Output | Variant([0x8000000460000009600000096000000960000009200000000000000001200000000000000000200000000000000002200000000000000003]) | +--------+-------------------------------------------------------------------------------------------------------------------------------+ @@ -1633,7 +1767,7 @@ evaluation (internal): +--------+-------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------+ -| event1 | Boolean([0b____0001]) | +| event1 | Column(Boolean([0b____0001])) | | Output | Variant([0x8000000440000000300000003000000030000000]) | +--------+-------------------------------------------------------+ @@ -1643,7 +1777,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | | Output | Variant([0x800000032000000a2000000a2000000a70000000000000006e027000000000000000dc0270000000000000014a02]) | +--------+-----------------------------------------------------------------------------------------------------------+ @@ -1655,8 +1789,8 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| s | StringColumn[abc, def, opq, xyz] | +| a | Column(Int64([4, 3, 2, 1])) | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | Variant([0x4000000410000003100000031000000310000003200000022000000220000002200000026162636465666f707178797a4004400340024001]) | +--------+-------------------------------------------------------------------------------------------------------------------------------+ @@ -1666,8 +1800,8 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | +| b | Column(UInt64([1, 2, 3, 4])) | +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | | Output | Variant([0x40000003100000011000000110000001200000022000000220000002616364500150035004]) | +--------+-----------------------------------------------------------------------------------------+ @@ -1679,8 +1813,8 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | +| s | Column(StringColumn[abc, def, opq, xyz]) | +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | | Output | Variant([0x400000031000000310000003100000032000000a2000000a2000000a61626364656678797a70000000000000006e027000000000000000dc0270000000000000014a02]) | +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1690,19 +1824,19 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1]), validity: [0b_______1] } | +--------+---------------------------------------------------------------+ ast: mode(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 1 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 1 } | ++--------+-----------------------------+ ast: mode(d) @@ -1710,19 +1844,19 @@ evaluation (internal): +--------+----------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------+ -| d | UInt64([1, 1, 1, 1]) | +| d | Column(UInt64([1, 1, 1, 1])) | | Output | NullableColumn { column: UInt64([1]), validity: [0b_______1] } | +--------+----------------------------------------------------------------+ ast: mode(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0]), validity: [0b_______0] } | ++----------+---------------------------------------------------------------------------------+ ast: st_collect(to_geometry('point(10 20)')) @@ -1730,7 +1864,7 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x010400000004000000010100000000000000000024400000000000003440010100000000000000000024400000000000003440010100000000000000000024400000000000003440010100000000000000000024400000000000003440]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1740,19 +1874,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x0105000020e6100000040000000102000000020000000000000000002440000000000000344000000000000044400000000000004940010200000002000000000000000000244000000000000034400000000000004440000000000000494001020000000200000000000000000024400000000000003440000000000000444000000000000049400102000000020000000000000000002440000000000000344000000000000044400000000000004940]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: st_collect(NULL) evaluation (internal): -+--------+-------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | -| Output | NullableColumn { column: Geometry([0x]), validity: [0b_______0] } | -+--------+-------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------+ +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | +| Output | NullableColumn { column: Geometry([0x]), validity: [0b_______0] } | ++--------+----------------------------------------------------------------------+ ast: st_collect(to_geometry(point)) @@ -1760,7 +1894,7 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x0104000000040000000101000000000000000000f03f000000000000f03f010100000000000000000000400000000000000040010100000000000000000008400000000000000840010100000000000000000010400000000000001040]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1770,7 +1904,7 @@ evaluation (internal): +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point_null | NullableColumn { column: StringColumn[POINT(1 1), , POINT(3 3), POINT(4 4)], validity: [0b____1101] } | +| point_null | Column(NullableColumn { column: StringColumn[POINT(1 1), , POINT(3 3), POINT(4 4)], validity: [0b____1101] }) | | Output | NullableColumn { column: Geometry([0x0104000000030000000101000000000000000000f03f000000000000f03f010100000000000000000008400000000000000840010100000000000000000010400000000000001040]), validity: [0b_______1] } | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1780,7 +1914,7 @@ evaluation (internal): +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| line_string | StringColumn[LINESTRING(0 0, 1 1), LINESTRING(1 1, 2 2), LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)] | +| line_string | Column(StringColumn[LINESTRING(0 0, 1 1), LINESTRING(1 1, 2 2), LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)]) | | Output | NullableColumn { column: Geometry([0x01050000000400000001020000000200000000000000000000000000000000000000000000000000f03f000000000000f03f010200000002000000000000000000f03f000000000000f03f0000000000000040000000000000004001020000000200000000000000000000400000000000000040000000000000084000000000000008400102000000020000000000000000000840000000000000084000000000000010400000000000001040]), validity: [0b_______1] } | +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1790,7 +1924,7 @@ evaluation (internal): +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| line_string_null | NullableColumn { column: StringColumn[LINESTRING(0 0, 1 1), , LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)], validity: [0b____1101] } | +| line_string_null | Column(NullableColumn { column: StringColumn[LINESTRING(0 0, 1 1), , LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)], validity: [0b____1101] }) | | Output | NullableColumn { column: Geometry([0x01050000000300000001020000000200000000000000000000000000000000000000000000000000f03f000000000000f03f01020000000200000000000000000000400000000000000040000000000000084000000000000008400102000000020000000000000000000840000000000000084000000000000010400000000000001040]), validity: [0b_______1] } | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1800,7 +1934,7 @@ evaluation (internal): +---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| polygon | StringColumn[POLYGON((0 0, 1 0, 1 1, 0 1, 0 0)), POLYGON((1 1, 2 1, 2 2, 1 2, 1 1)), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))] | +| polygon | Column(StringColumn[POLYGON((0 0, 1 0, 1 1, 0 1, 0 0)), POLYGON((1 1, 2 1, 2 2, 1 2, 1 1)), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))]) | | Output | NullableColumn { column: Geometry([0x0106000000040000000103000000010000000500000000000000000000000000000000000000000000000000f03f0000000000000000000000000000f03f000000000000f03f0000000000000000000000000000f03f0000000000000000000000000000000001030000000100000005000000000000000000f03f000000000000f03f0000000000000040000000000000f03f00000000000000400000000000000040000000000000f03f0000000000000040000000000000f03f000000000000f03f010300000001000000050000000000000000000040000000000000004000000000000008400000000000000040000000000000084000000000000008400000000000000040000000000000084000000000000000400000000000000040010300000001000000050000000000000000000840000000000000084000000000000010400000000000000840000000000000104000000000000010400000000000000840000000000000104000000000000008400000000000000840]), validity: [0b_______1] } | +---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1810,7 +1944,7 @@ evaluation (internal): +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| mixed_geom | StringColumn[POINT(0 0), LINESTRING(1 1, 2 2), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)] | +| mixed_geom | Column(StringColumn[POINT(0 0), LINESTRING(1 1, 2 2), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x010700000004000000010100000000000000000000000000000000000000010200000002000000000000000000f03f000000000000f03f00000000000000400000000000000040010300000001000000050000000000000000000040000000000000004000000000000008400000000000000040000000000000084000000000000008400000000000000040000000000000084000000000000000400000000000000040010100000000000000000010400000000000001040]), validity: [0b_______1] } | +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1820,7 +1954,7 @@ evaluation (internal): +-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| mixed_geom_null | NullableColumn { column: StringColumn[POINT(0 0), , POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)], validity: [0b____1101] } | +| mixed_geom_null | Column(NullableColumn { column: StringColumn[POINT(0 0), , POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)], validity: [0b____1101] }) | | Output | NullableColumn { column: Geometry([0x010700000003000000010100000000000000000000000000000000000000010300000001000000050000000000000000000040000000000000004000000000000008400000000000000040000000000000084000000000000008400000000000000040000000000000084000000000000000400000000000000040010100000000000000000010400000000000001040]), validity: [0b_______1] } | +-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1830,7 +1964,7 @@ evaluation (internal): +------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point_4326 | StringColumn[SRID=4326;POINT(116.3 39.9), SRID=4326;POINT(121.4 31.2), SRID=4326;POINT(113.2 23.1), SRID=4326;POINT(114.1 22.5)] | +| point_4326 | Column(StringColumn[SRID=4326;POINT(116.3 39.9), SRID=4326;POINT(121.4 31.2), SRID=4326;POINT(113.2 23.1), SRID=4326;POINT(114.1 22.5)]) | | Output | NullableColumn { column: Geometry([0x0104000020e61000000400000001010000003333333333135d403333333333f3434001010000009a99999999595e403333333333333f400101000000cdcccccccc4c5c409a9999999919374001010000006666666666865c400000000000803640]), validity: [0b_______1] } | +------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1840,7 +1974,7 @@ evaluation (internal): +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| line_string_4326 | StringColumn[SRID=4326;LINESTRING(116.3 39.9, 121.4 31.2), SRID=4326;LINESTRING(121.4 31.2, 113.2 23.1), SRID=4326;LINESTRING(113.2 23.1, 114.1 22.5), SRID=4326;LINESTRING(114.1 22.5, 116.3 39.9)] | +| line_string_4326 | Column(StringColumn[SRID=4326;LINESTRING(116.3 39.9, 121.4 31.2), SRID=4326;LINESTRING(121.4 31.2, 113.2 23.1), SRID=4326;LINESTRING(113.2 23.1, 114.1 22.5), SRID=4326;LINESTRING(114.1 22.5, 116.3 39.9)]) | | Output | NullableColumn { column: Geometry([0x0105000020e6100000040000000102000000020000003333333333135d403333333333f343409a99999999595e403333333333333f400102000000020000009a99999999595e403333333333333f40cdcccccccc4c5c409a99999999193740010200000002000000cdcccccccc4c5c409a999999991937406666666666865c4000000000008036400102000000020000006666666666865c4000000000008036403333333333135d403333333333f34340]), validity: [0b_______1] } | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1850,7 +1984,7 @@ evaluation (internal): +--------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| polygon_4326 | StringColumn[SRID=4326;POLYGON((116 39, 117 39, 117 40, 116 40, 116 39)), SRID=4326;POLYGON((121 31, 122 31, 122 32, 121 32, 121 31)), SRID=4326;POLYGON((113 23, 114 23, 114 24, 113 24, 113 23)), SRID=4326;POLYGON((114 22, 115 22, 115 23, 114 23, 114 22))] | +| polygon_4326 | Column(StringColumn[SRID=4326;POLYGON((116 39, 117 39, 117 40, 116 40, 116 39)), SRID=4326;POLYGON((121 31, 122 31, 122 32, 121 32, 121 31)), SRID=4326;POLYGON((113 23, 114 23, 114 24, 113 24, 113 23)), SRID=4326;POLYGON((114 22, 115 22, 115 23, 114 23, 114 22))]) | | Output | NullableColumn { column: Geometry([0x0106000020e610000004000000010300000001000000050000000000000000005d4000000000008043400000000000405d4000000000008043400000000000405d4000000000000044400000000000005d4000000000000044400000000000005d400000000000804340010300000001000000050000000000000000405e400000000000003f400000000000805e400000000000003f400000000000805e4000000000000040400000000000405e4000000000000040400000000000405e400000000000003f40010300000001000000050000000000000000405c4000000000000037400000000000805c4000000000000037400000000000805c4000000000000038400000000000405c4000000000000038400000000000405c400000000000003740010300000001000000050000000000000000805c4000000000000036400000000000c05c4000000000000036400000000000c05c4000000000000037400000000000805c4000000000000037400000000000805c400000000000003640]), validity: [0b_______1] } | +--------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1860,7 +1994,7 @@ evaluation (internal): +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| mixed_3857 | StringColumn[SRID=3857;POINT(12947889.3 4852834.1), SRID=3857;LINESTRING(13515330.8 3642091.4, 12600089.2 2632873.5), SRID=3857;POLYGON((12700000 2600000, 12800000 2600000, 12800000 2700000, 12700000 2700000, 12700000 2600000)), SRID=3857;POINT(12959772.9 2551529.8)] | +| mixed_3857 | Column(StringColumn[SRID=3857;POINT(12947889.3 4852834.1), SRID=3857;LINESTRING(13515330.8 3642091.4, 12600089.2 2632873.5), SRID=3857;POLYGON((12700000 2600000, 12800000 2600000, 12800000 2700000, 12700000 2700000, 12700000 2600000)), SRID=3857;POINT(12959772.9 2551529.8)]) | | Output | NullableColumn { column: Geometry([0x0107000020110f00000400000001010000009a99992936b2684166666686188352410102000000020000009a99995948c76941333333b375c94b416666662663086841000000c05416444101030000000100000005000000000000002c3968410000000020d6434100000000006a68410000000020d6434100000000006a68410000000070994441000000002c3968410000000070994441000000002c3968410000000020d643410101000000cdcccc9c03b86841666666e674774341]), validity: [0b_______1] } | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ diff --git a/src/query/functions/tests/it/aggregates/testdata/agg_group_by.txt b/src/query/functions/tests/it/aggregates/testdata/agg_group_by.txt index 1ecc2328bd11b..a6803bb629250 100644 --- a/src/query/functions/tests/it/aggregates/testdata/agg_group_by.txt +++ b/src/query/functions/tests/it/aggregates/testdata/agg_group_by.txt @@ -1,154 +1,174 @@ ast: count(1) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([2, 2]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([2, 2]) | ++--------+-----------------------------+ + + +ast: count(const_int) +evaluation (internal): ++-----------+----------------------------------------+ +| Column | Data | ++-----------+----------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | UInt64([2, 2]) | ++-----------+----------------------------------------+ + + +ast: count(const_int_null) +evaluation (internal): ++----------------+-----------------------------------------+ +| Column | Data | ++----------------+-----------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | UInt64([0, 0]) | ++----------------+-----------------------------------------+ ast: count() evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([2, 2]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([2, 2]) | ++--------+-----------------------------+ ast: count(a) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([2, 2]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([2, 2]) | ++--------+-----------------------------+ ast: count(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([1, 1]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([1, 1]) | ++--------+---------------------------------------------------------------------------------+ ast: sum0(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([1, 2]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([1, 2]) | ++--------+---------------------------------------------------------------------------------+ ast: count(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | UInt64([0, 0]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | UInt64([0, 0]) | ++----------+---------------------------------------------------------------------------------+ ast: count_distinct(null) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([0, 0]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0, 0]) | ++--------+-----------------------------+ ast: count_distinct(null,null) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([0, 0]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0, 0]) | ++--------+-----------------------------+ ast: count_distinct(1) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([1, 1]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([1, 1]) | ++--------+-----------------------------+ ast: count_distinct(a) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([2, 2]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([2, 2]) | ++--------+-----------------------------+ ast: count_distinct(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([1, 1]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([1, 1]) | ++--------+---------------------------------------------------------------------------------+ ast: count_distinct(x_null,a) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([2, 2]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([2, 2]) | ++--------+---------------------------------------------------------------------------------+ ast: count_distinct(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | UInt64([0, 0]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | UInt64([0, 0]) | ++----------+---------------------------------------------------------------------------------+ ast: count_distinct(all_null,s) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| s | StringColumn[abc, def, opq, xyz] | -| Output | UInt64([2, 2]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| s | Column(StringColumn[abc, def, opq, xyz]) | +| Output | UInt64([2, 2]) | ++----------+---------------------------------------------------------------------------------+ ast: count_distinct(s_null,s) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | UInt64([2, 2]) | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s | Column(StringColumn[abc, def, opq, xyz]) | +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | UInt64([2, 2]) | ++--------+------------------------------------------------------------------------------------+ ast: sum(1) @@ -156,7 +176,7 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt64([2, 2]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ @@ -166,29 +186,49 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([6, 4]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ +ast: sum(const_int) +evaluation (internal): ++-----------+--------------------------------------------------------------------+ +| Column | Data | ++-----------+--------------------------------------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int64([10, 10]), validity: [0b______11] } | ++-----------+--------------------------------------------------------------------+ + + +ast: sum(const_int_null) +evaluation (internal): ++----------------+------------------------------------------------------------------+ +| Column | Data | ++----------------+------------------------------------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int64([0, 0]), validity: [0b______00] } | ++----------------+------------------------------------------------------------------+ + + ast: sum(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: sum(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: avg(1) @@ -196,7 +236,7 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([1, 1]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ @@ -206,111 +246,121 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([3, 2]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ ast: avg(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | NullableColumn { column: Decimal64([1.1000, 2.7500]), validity: [0b______11] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | NullableColumn { column: Decimal64([1.1000, 2.7500]), validity: [0b______11] } | ++--------+------------------------------------------------------------------------------------------------+ ast: avg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: avg(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: uniq(1) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([1, 1]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([1, 1]) | ++--------+-----------------------------+ ast: uniq(c) evaluation (internal): -+--------+----------------------+ -| Column | Data | -+--------+----------------------+ -| c | UInt64([1, 2, 1, 3]) | -| Output | UInt64([1, 2]) | -+--------+----------------------+ ++--------+------------------------------+ +| Column | Data | ++--------+------------------------------+ +| c | Column(UInt64([1, 2, 1, 3])) | +| Output | UInt64([1, 2]) | ++--------+------------------------------+ ast: uniq(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([1, 1]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([1, 1]) | ++--------+---------------------------------------------------------------------------------+ ast: uniq(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | UInt64([0, 0]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | UInt64([0, 0]) | ++----------+---------------------------------------------------------------------------------+ ast: count_if(1, x_null is null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | UInt64([1, 1]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | UInt64([1, 1]) | ++--------+---------------------------------------------------------------------------------+ + + +ast: count_if(1, false) +evaluation (internal): ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0, 0]) | ++--------+-----------------------------+ ast: sum_if(a, x_null is null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: sum_if(b, x_null is null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: sum_distinct(a) @@ -318,7 +368,7 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([6, 4]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ @@ -328,29 +378,29 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| c | UInt64([1, 2, 1, 3]) | +| c | Column(UInt64([1, 2, 1, 3])) | | Output | NullableColumn { column: UInt64([1, 5]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ ast: sum_distinct(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: sum_distinct(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: max(1) @@ -358,19 +408,19 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1, 1]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ ast: max(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 2 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 2 } | ++--------+-----------------------------+ ast: max(a) @@ -378,7 +428,7 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([4, 3]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ @@ -388,29 +438,29 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ ast: max(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: max(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: min(1) @@ -418,19 +468,39 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1, 1]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ ast: min(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 2 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 2 } | ++--------+-----------------------------+ + + +ast: min(const_int) +evaluation (internal): ++-----------+------------------------------------------------------------------+ +| Column | Data | ++-----------+------------------------------------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int32([5, 5]), validity: [0b______11] } | ++-----------+------------------------------------------------------------------+ + + +ast: min(const_int_null) +evaluation (internal): ++----------------+------------------------------------------------------------------+ +| Column | Data | ++----------------+------------------------------------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int32([0, 0]), validity: [0b______00] } | ++----------------+------------------------------------------------------------------+ ast: min(a) @@ -438,7 +508,7 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ @@ -448,29 +518,29 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ ast: min(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: min(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: any(1) @@ -478,19 +548,19 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1, 1]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ ast: any(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 2 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 2 } | ++--------+-----------------------------+ ast: any(a) @@ -498,7 +568,7 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Int64([4, 3]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ @@ -508,39 +578,39 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ ast: any(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: any(y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: any(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_min(a, b) @@ -548,8 +618,8 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Int64([4, 3]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ @@ -559,54 +629,54 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ ast: arg_min(y_null, a) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_min(a, y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_min(all_null, a) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_min(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Int64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Int64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_max(a, b) @@ -614,8 +684,8 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ @@ -625,54 +695,98 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: UInt64([1, 2]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ +ast: arg_max(const_int, a) +evaluation (internal): ++-----------+------------------------------------------------------------------+ +| Column | Data | ++-----------+------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int32([5, 5]), validity: [0b______11] } | ++-----------+------------------------------------------------------------------+ + + +ast: arg_max(const_int_null, a) +evaluation (internal): ++----------------+------------------------------------------------------------------+ +| Column | Data | ++----------------+------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int32([0, 0]), validity: [0b______00] } | ++----------------+------------------------------------------------------------------+ + + +ast: arg_max(a, const_int) +evaluation (internal): ++-----------+------------------------------------------------------------------+ +| Column | Data | ++-----------+------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | NullableColumn { column: Int64([4, 3]), validity: [0b______11] } | ++-----------+------------------------------------------------------------------+ + + +ast: arg_max(a, const_int_null) +evaluation (internal): ++----------------+------------------------------------------------------------------+ +| Column | Data | ++----------------+------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | NullableColumn { column: Int64([0, 0]), validity: [0b______00] } | ++----------------+------------------------------------------------------------------+ + + ast: arg_max(y_null, a) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: UInt64([3, 4]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_max(a, y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | NullableColumn { column: Int64([2, 1]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: arg_max(all_null, a) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: arg_max(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Int64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Int64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: covar_samp(a, b) @@ -680,32 +794,32 @@ evaluation (internal): +--------+----------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Float64([-2, -2]), validity: [0b______11] } | +--------+----------------------------------------------------------------------+ ast: covar_samp(a, x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([inf, inf]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([inf, inf]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: covar_samp(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: covar_pop(a, b) @@ -713,32 +827,32 @@ evaluation (internal): +--------+----------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: Float64([-1, -1]), validity: [0b______11] } | +--------+----------------------------------------------------------------------+ ast: covar_pop(a, x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: covar_pop(a, all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: retention(a > 1, b > 1) @@ -746,8 +860,8 @@ evaluation (internal): +--------+--------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | NullableColumn { column: ArrayColumn { values: UInt8([1, 1, 1, 1]), offsets: [0, 2, 4] }, validity: [0b______11] } | +--------+--------------------------------------------------------------------------------------------------------------------+ @@ -757,9 +871,9 @@ evaluation (internal): +--------+--------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | | Output | NullableColumn { column: ArrayColumn { values: UInt8([1, 0, 0, 1, 1, 1]), offsets: [0, 3, 6] }, validity: [0b______11] } | +--------+--------------------------------------------------------------------------------------------------------------------------+ @@ -769,10 +883,10 @@ evaluation (internal): +----------+----------------------------------------------------------------------------------------------------------+ | Column | Data | +----------+----------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| b | UInt64([1, 2, 3, 4]) | -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | +| a | Column(Int64([4, 3, 2, 1])) | +| b | Column(UInt64([1, 2, 3, 4])) | +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | | Output | NullableColumn { column: ArrayColumn { values: UInt8([]), offsets: [0, 0, 0] }, validity: [0b______00] } | +----------+----------------------------------------------------------------------------------------------------------+ @@ -782,19 +896,19 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([1, 1]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ ast: stddev(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | ++--------+---------------------------------------------------------------------------------+ ast: stddev_samp(a) @@ -802,29 +916,29 @@ evaluation (internal): +--------+------------------------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([1.4142135623, 1.4142135623]), validity: [0b______11] } | +--------+------------------------------------------------------------------------------------------+ ast: stddev_samp(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | NullableColumn { column: Float64([0, 0.7778174593]), validity: [0b______10] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | NullableColumn { column: Float64([0, 0.7778174593]), validity: [0b______10] } | ++--------+------------------------------------------------------------------------------------------------+ ast: stddev_samp(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______00] } | ++--------+---------------------------------------------------------------------------------+ ast: kurtosis(a) @@ -832,19 +946,19 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ ast: kurtosis(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: skewness(a) @@ -852,19 +966,19 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ ast: skewness(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([0, 0]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: quantile_cont(0.8)(a) @@ -872,19 +986,19 @@ evaluation (internal): +--------+------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([3.6, 2.6]), validity: [0b______11] } | +--------+------------------------------------------------------------------------+ ast: quantile_cont(0.8)(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: quantile_cont(0.8)(a) @@ -892,19 +1006,19 @@ evaluation (internal): +--------+------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([3.6, 2.6]), validity: [0b______11] } | +--------+------------------------------------------------------------------------+ ast: quantile_cont(0.8)(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: quantile_tdigest(0.8)(a) @@ -912,19 +1026,19 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([4, 3]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ ast: quantile_tdigest(0.8)(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: median(a) @@ -932,19 +1046,19 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([3, 2]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ ast: median(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: median_tdigest(a) @@ -952,19 +1066,19 @@ evaluation (internal): +--------+--------------------------------------------------------------------+ | Column | Data | +--------+--------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: Float64([4, 3]), validity: [0b______11] } | +--------+--------------------------------------------------------------------+ ast: median_tdigest(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | NullableColumn { column: Float64([1, 2]), validity: [0b______11] } | ++--------+---------------------------------------------------------------------------------+ ast: window_funnel(2)(dt, event1, event2, event3) @@ -972,42 +1086,42 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| dt | Timestamp([1, 0, 2, 3]) | -| event1 | Boolean([0b____0001]) | -| event2 | Boolean([0b____0000]) | -| event3 | Boolean([0b____0000]) | +| dt | Column(Timestamp([1, 0, 2, 3])) | +| event1 | Column(Boolean([0b____0001])) | +| event2 | Column(Boolean([0b____0000])) | +| event3 | Column(Boolean([0b____0000])) | | Output | NullableColumn { column: UInt8([1, 0]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ ast: approx_count_distinct(a) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([2, 2]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([2, 2]) | ++--------+-----------------------------+ ast: approx_count_distinct(b) evaluation (internal): -+--------+----------------------+ -| Column | Data | -+--------+----------------------+ -| b | UInt64([1, 2, 3, 4]) | -| Output | UInt64([2, 2]) | -+--------+----------------------+ ++--------+------------------------------+ +| Column | Data | ++--------+------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| Output | UInt64([2, 2]) | ++--------+------------------------------+ ast: approx_count_distinct(null) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | UInt64([0, 0]) | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | UInt64([0, 0]) | ++--------+-----------------------------+ ast: array_agg(1) @@ -1015,17 +1129,37 @@ evaluation (internal): +--------+-----------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: UInt8([1, 1, 1, 1]), offsets: [0, 2, 4] } | +--------+-----------------------------------------------------------------+ +ast: array_agg(const_int) +evaluation (internal): ++-----------+-----------------------------------------------------------------+ +| Column | Data | ++-----------+-----------------------------------------------------------------+ +| const_int | Const(Number(5_i32), Number(Int32), 4) | +| Output | ArrayColumn { values: Int32([5, 5, 5, 5]), offsets: [0, 2, 4] } | ++-----------+-----------------------------------------------------------------+ + + +ast: array_agg(const_int_null) +evaluation (internal): ++----------------+-------------------------------------------------------+ +| Column | Data | ++----------------+-------------------------------------------------------+ +| const_int_null | Const(Null, Nullable(Number(Int32)), 4) | +| Output | ArrayColumn { values: Int32([]), offsets: [0, 0, 0] } | ++----------------+-------------------------------------------------------+ + + ast: array_agg('a') evaluation (internal): +--------+----------------------------------------------------------------------+ | Column | Data | +--------+----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: StringColumn[a, a, a, a], offsets: [0, 2, 4] } | +--------+----------------------------------------------------------------------+ @@ -1035,7 +1169,7 @@ evaluation (internal): +--------+-------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Null { len: 0 }, offsets: [0, 0, 0] } | +--------+-------------------------------------------------------------+ @@ -1045,7 +1179,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | ArrayColumn { values: Int64([4, 2, 3, 1]), offsets: [0, 2, 4] } | +--------+-----------------------------------------------------------------+ @@ -1055,29 +1189,29 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | ArrayColumn { values: UInt64([1, 3, 2, 4]), offsets: [0, 2, 4] } | +--------+------------------------------------------------------------------+ ast: array_agg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | ArrayColumn { values: UInt64([1, 2]), offsets: [0, 1, 2] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | ArrayColumn { values: UInt64([1, 2]), offsets: [0, 1, 2] } | ++--------+---------------------------------------------------------------------------------+ ast: array_agg(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | ArrayColumn { values: UInt64([]), offsets: [0, 0, 0] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | ArrayColumn { values: UInt64([]), offsets: [0, 0, 0] } | ++----------+---------------------------------------------------------------------------------+ ast: array_agg(dt) @@ -1085,7 +1219,7 @@ evaluation (internal): +--------+---------------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------------+ -| dt | Timestamp([1, 0, 2, 3]) | +| dt | Column(Timestamp([1, 0, 2, 3])) | | Output | ArrayColumn { values: Timestamp([1, 2, 0, 3]), offsets: [0, 2, 4] } | +--------+---------------------------------------------------------------------+ @@ -1095,19 +1229,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| event1 | Boolean([0b____0001]) | +| event1 | Column(Boolean([0b____0001])) | | Output | ArrayColumn { values: Boolean([0b____0001]), offsets: [0, 2, 4] } | +--------+-------------------------------------------------------------------+ ast: array_agg(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([1.10, 2.20, 3.30]), offsets: [0, 1, 3] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([1.10, 2.20, 3.30]), offsets: [0, 1, 3] } | ++--------+------------------------------------------------------------------------------------------------+ ast: array_agg(s) @@ -1115,7 +1249,7 @@ evaluation (internal): +--------+------------------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | ArrayColumn { values: StringColumn[abc, opq, def, xyz], offsets: [0, 2, 4] } | +--------+------------------------------------------------------------------------------+ @@ -1125,7 +1259,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| json | StringColumn[{"k1":"v1","k2":"v2"}, [1,2,3,"abc"], 99999, "xyz"] | +| json | Column(StringColumn[{"k1":"v1","k2":"v2"}, [1,2,3,"abc"], 99999, "xyz"]) | | Output | ArrayColumn { values: Variant([0x40000002100000021000000210000002100000026b316b3276317632, 0x2000000020000005500001869f, 0x8000000420000002200000022000000210000003500150025003616263, 0x200000001000000378797a]), offsets: [0, 2, 4] } | +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1135,19 +1269,19 @@ evaluation (internal): +--------+---------------------------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abcopq, defxyz], validity: [0b______11] } | +--------+---------------------------------------------------------------------------------+ ast: string_agg(s_null) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[ac, d], validity: [0b______11] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[ac, d], validity: [0b______11] } | ++--------+------------------------------------------------------------------------------------+ ast: string_agg(s, '|') @@ -1155,19 +1289,19 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abc|opq, def|xyz], validity: [0b______11] } | +--------+-----------------------------------------------------------------------------------+ ast: string_agg(s_null, '-') evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[a-c, d], validity: [0b______11] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[a-c, d], validity: [0b______11] } | ++--------+------------------------------------------------------------------------------------+ ast: listagg(s) @@ -1175,19 +1309,19 @@ evaluation (internal): +--------+---------------------------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abcopq, defxyz], validity: [0b______11] } | +--------+---------------------------------------------------------------------------------+ ast: listagg(s_null) evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[ac, d], validity: [0b______11] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[ac, d], validity: [0b______11] } | ++--------+------------------------------------------------------------------------------------+ ast: listagg(s, '|') @@ -1195,265 +1329,265 @@ evaluation (internal): +--------+---------------------------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | NullableColumn { column: StringColumn[abcopq, defxyz], validity: [0b______11] } | +--------+---------------------------------------------------------------------------------+ ast: listagg(s_null, '-') evaluation (internal): -+--------+----------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------+ -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | -| Output | NullableColumn { column: StringColumn[ac, d], validity: [0b______11] } | -+--------+----------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------+ +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | +| Output | NullableColumn { column: StringColumn[ac, d], validity: [0b______11] } | ++--------+------------------------------------------------------------------------------------+ ast: bitmap_and_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([3, 3]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([3, 3]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_or_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([7, 7]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([7, 7]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_xor_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([4, 4]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([4, 4]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_not_count(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([2, 2]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([2, 2]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: intersect_count(1, 2, 3, 4)(bm, b) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([3, 3]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([3, 3]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: intersect_count(1, 2)(bm, b) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: UInt64([5, 5]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: UInt64([5, 5]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_union(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: Bitmap([0x48420100070000000000000000010000000000000002000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x48420100070100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000000700000000000000]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: Bitmap([0x48420100070000000000000000010000000000000002000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x48420100070100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000000700000000000000]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: bitmap_intersect(bm) evaluation (internal): -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| bm | Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000]) | -| Output | NullableColumn { column: Bitmap([0x4842010003020000000000000003000000000000000400000000000000, 0x4842010003030000000000000004000000000000000500000000000000]), validity: [0b______11] } | -+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| bm | Column(Bitmap([0x484201000500000000000000000100000000000000020000000000000003000000000000000400000000000000, 0x484201000501000000000000000200000000000000030000000000000004000000000000000500000000000000, 0x484201000502000000000000000300000000000000040000000000000005000000000000000600000000000000, 0x484201000503000000000000000400000000000000050000000000000006000000000000000700000000000000])) | +| Output | NullableColumn { column: Bitmap([0x4842010003020000000000000003000000000000000400000000000000, 0x4842010003030000000000000004000000000000000500000000000000]), validity: [0b______11] } | ++--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: group_array_moving_avg(1) evaluation (internal): -+--------+------------------------------------------------------------------------+ -| Column | Data | -+--------+------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | ArrayColumn { values: Float64([0.25, 0.5, 0.75, 1]), offsets: [0, 4] } | -+--------+------------------------------------------------------------------------+ ++--------+-----------------------------------------------------------------------+ +| Column | Data | ++--------+-----------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | ArrayColumn { values: Float64([0.5, 1, 0.5, 1]), offsets: [0, 2, 4] } | ++--------+-----------------------------------------------------------------------+ error: AggregateArrayMovingAvgFunction does not support type 'String' ast: group_array_moving_avg(NULL) evaluation (internal): -+--------+----------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | ArrayColumn { values: Float64([0, 0, 0, 0]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------+ ++--------+-------------------------------------------------------------------+ +| Column | Data | ++--------+-------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | ArrayColumn { values: Float64([0, 0, 0, 0]), offsets: [0, 2, 4] } | ++--------+-------------------------------------------------------------------+ ast: group_array_moving_avg(a) evaluation (internal): -+--------+------------------------------------------------------------------------+ -| Column | Data | -+--------+------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | ArrayColumn { values: Float64([1, 1.75, 2.25, 2.5]), offsets: [0, 4] } | -+--------+------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | ArrayColumn { values: Float64([2, 3, 1.5, 2]), offsets: [0, 2, 4] } | ++--------+---------------------------------------------------------------------+ ast: group_array_moving_avg(2)(b) evaluation (internal): -+--------+------------------------------------------------------------------------+ -| Column | Data | -+--------+------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| Output | ArrayColumn { values: Float64([0.5, 1.5, 2.5, 3.5]), offsets: [0, 4] } | -+--------+------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| Output | ArrayColumn { values: Float64([0.5, 2, 1, 3]), offsets: [0, 2, 4] } | ++--------+---------------------------------------------------------------------+ ast: group_array_moving_avg(x_null) evaluation (internal): -+--------+--------------------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | ArrayColumn { values: Float64([0.25, 0.75, 1.5, 2.5]), offsets: [0, 4] } | -+--------+--------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | ArrayColumn { values: Float64([0.5, 0.5, 1, 1]), offsets: [0, 2, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_avg(1)(y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | ArrayColumn { values: Float64([1, 2, 3, 4]), offsets: [0, 4] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | ArrayColumn { values: Float64([0, 3, 0, 4]), offsets: [0, 2, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_avg(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([0.2750, 0.8250, 0.8250, 1.6500]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([0.5500, 0.5500, 1.1000, 2.7500]), offsets: [0, 2, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: group_array_moving_avg(2)(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([0.5500, 1.6500, 1.1000, 1.6500]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([0.5500, 0.5500, 1.1000, 2.7500]), offsets: [0, 2, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: group_array_moving_sum(1) evaluation (internal): -+--------+---------------------------------------------------------------+ -| Column | Data | -+--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | ArrayColumn { values: UInt64([1, 2, 3, 4]), offsets: [0, 4] } | -+--------+---------------------------------------------------------------+ ++--------+------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | ArrayColumn { values: UInt64([1, 2, 1, 2]), offsets: [0, 2, 4] } | ++--------+------------------------------------------------------------------+ error: AggregateArrayMovingSumFunction does not support type 'String' ast: group_array_moving_sum(NULL) evaluation (internal): -+--------+--------------------------------------------------------------+ -| Column | Data | -+--------+--------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | ArrayColumn { values: Int64([0, 0, 0, 0]), offsets: [0, 4] } | -+--------+--------------------------------------------------------------+ ++--------+-----------------------------------------------------------------+ +| Column | Data | ++--------+-----------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | ArrayColumn { values: Int64([0, 0, 0, 0]), offsets: [0, 2, 4] } | ++--------+-----------------------------------------------------------------+ ast: group_array_moving_sum(a) evaluation (internal): -+--------+---------------------------------------------------------------+ -| Column | Data | -+--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | ArrayColumn { values: Int64([4, 7, 9, 10]), offsets: [0, 4] } | -+--------+---------------------------------------------------------------+ ++--------+-----------------------------------------------------------------+ +| Column | Data | ++--------+-----------------------------------------------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | ArrayColumn { values: Int64([4, 6, 3, 4]), offsets: [0, 2, 4] } | ++--------+-----------------------------------------------------------------+ ast: group_array_moving_sum(2)(b) evaluation (internal): -+--------+---------------------------------------------------------------+ -| Column | Data | -+--------+---------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| Output | ArrayColumn { values: UInt64([1, 3, 5, 7]), offsets: [0, 4] } | -+--------+---------------------------------------------------------------+ ++--------+------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------+ +| b | Column(UInt64([1, 2, 3, 4])) | +| Output | ArrayColumn { values: UInt64([1, 4, 2, 6]), offsets: [0, 2, 4] } | ++--------+------------------------------------------------------------------+ ast: group_array_moving_sum(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | ArrayColumn { values: UInt64([1, 3, 6, 10]), offsets: [0, 4] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | ArrayColumn { values: UInt64([1, 1, 2, 2]), offsets: [0, 2, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_sum(1)(y_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| y_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] } | -| Output | ArrayColumn { values: UInt64([1, 2, 3, 4]), offsets: [0, 4] } | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| y_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____1100] }) | +| Output | ArrayColumn { values: UInt64([0, 3, 0, 4]), offsets: [0, 2, 4] } | ++--------+---------------------------------------------------------------------------------+ ast: group_array_moving_sum(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([1.10, 3.30, 3.30, 6.60]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([1.10, 1.10, 2.20, 5.50]), offsets: [0, 2, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: group_array_moving_sum(2)(dec) evaluation (internal): -+--------+----------------------------------------------------------------------------------------+ -| Column | Data | -+--------+----------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | -| Output | ArrayColumn { values: Decimal64([1.10, 3.30, 2.20, 3.30]), offsets: [0, 4] } | -+--------+----------------------------------------------------------------------------------------+ ++--------+------------------------------------------------------------------------------------------------+ +| Column | Data | ++--------+------------------------------------------------------------------------------------------------+ +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | +| Output | ArrayColumn { values: Decimal64([1.10, 1.10, 2.20, 5.50]), offsets: [0, 2, 4] } | ++--------+------------------------------------------------------------------------------------------------+ ast: json_agg(a) @@ -1461,19 +1595,19 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x80000004200000022000000220000002200000024004400340024001]) | +--------+-----------------------------------------------------------------------+ ast: json_agg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | Variant([0x80000002200000022000000250015002]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | Variant([0x80000002200000022000000250015002]) | ++--------+---------------------------------------------------------------------------------+ ast: json_agg(dec) @@ -1481,7 +1615,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | | Output | Variant([0x800000032000000a2000000a2000000a70000000000000006e027000000000000000dc0270000000000000014a02]) | +--------+-----------------------------------------------------------------------------------------------------------+ @@ -1491,7 +1625,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x80000004200000022000000220000002200000025001500150015001]) | +--------+-----------------------------------------------------------------------+ @@ -1501,19 +1635,19 @@ evaluation (internal): +--------+---------------------------------------------------------------+ | Column | Data | +--------+---------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x800000041000000110000001100000011000000161616161]) | +--------+---------------------------------------------------------------+ ast: json_array_agg(NULL) evaluation (internal): -+--------+-----------------------+ -| Column | Data | -+--------+-----------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Variant([0x80000000]) | -+--------+-----------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Variant([0x80000000]) | ++--------+-----------------------------+ ast: json_array_agg(a) @@ -1521,7 +1655,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | Variant([0x80000004200000022000000220000002200000024004400340024001]) | +--------+-----------------------------------------------------------------------+ @@ -1531,29 +1665,29 @@ evaluation (internal): +--------+-----------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | +| b | Column(UInt64([1, 2, 3, 4])) | | Output | Variant([0x80000004200000022000000220000002200000025001500250035004]) | +--------+-----------------------------------------------------------------------+ ast: json_array_agg(x_null) evaluation (internal): -+--------+-------------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------------+ -| x_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] } | -| Output | Variant([0x80000002200000022000000250015002]) | -+--------+-------------------------------------------------------------------------+ ++--------+---------------------------------------------------------------------------------+ +| Column | Data | ++--------+---------------------------------------------------------------------------------+ +| x_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0011] }) | +| Output | Variant([0x80000002200000022000000250015002]) | ++--------+---------------------------------------------------------------------------------+ ast: json_array_agg(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | Variant([0x80000000]) | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | Variant([0x80000000]) | ++----------+---------------------------------------------------------------------------------+ ast: json_array_agg(dt) @@ -1561,7 +1695,7 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------+ -| dt | Timestamp([1, 0, 2, 3]) | +| dt | Column(Timestamp([1, 0, 2, 3])) | | Output | Variant([0x8000000460000009600000096000000960000009200000000000000001200000000000000000200000000000000002200000000000000003]) | +--------+-------------------------------------------------------------------------------------------------------------------------------+ @@ -1571,7 +1705,7 @@ evaluation (internal): +--------+-------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------+ -| event1 | Boolean([0b____0001]) | +| event1 | Column(Boolean([0b____0001])) | | Output | Variant([0x8000000440000000300000003000000030000000]) | +--------+-------------------------------------------------------+ @@ -1581,7 +1715,7 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------+ -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | | Output | Variant([0x800000032000000a2000000a2000000a70000000000000006e027000000000000000dc0270000000000000014a02]) | +--------+-----------------------------------------------------------------------------------------------------------+ @@ -1593,8 +1727,8 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | -| s | StringColumn[abc, def, opq, xyz] | +| a | Column(Int64([4, 3, 2, 1])) | +| s | Column(StringColumn[abc, def, opq, xyz]) | | Output | Variant([0x4000000410000003100000031000000310000003200000022000000220000002200000026162636465666f707178797a4004400340024001]) | +--------+-------------------------------------------------------------------------------------------------------------------------------+ @@ -1604,8 +1738,8 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------+ -| b | UInt64([1, 2, 3, 4]) | -| s_null | NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] } | +| b | Column(UInt64([1, 2, 3, 4])) | +| s_null | Column(NullableColumn { column: StringColumn[a, , c, d], validity: [0b____1101] }) | | Output | Variant([0x40000003100000011000000110000001200000022000000220000002616364500150035004]) | +--------+-----------------------------------------------------------------------------------------+ @@ -1617,8 +1751,8 @@ evaluation (internal): +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------+ -| s | StringColumn[abc, def, opq, xyz] | -| dec | NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] } | +| s | Column(StringColumn[abc, def, opq, xyz]) | +| dec | Column(NullableColumn { column: Decimal64([1.10, 2.20, 0.00, 3.30]), validity: [0b____1011] }) | | Output | Variant([0x400000031000000310000003100000032000000a2000000a2000000a61626364656678797a70000000000000006e027000000000000000dc0270000000000000014a02]) | +--------+-----------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1628,19 +1762,19 @@ evaluation (internal): +--------+------------------------------------------------------------------+ | Column | Data | +--------+------------------------------------------------------------------+ -| a | Int64([4, 3, 2, 1]) | +| a | Column(Int64([4, 3, 2, 1])) | | Output | NullableColumn { column: UInt8([1, 1]), validity: [0b______11] } | +--------+------------------------------------------------------------------+ ast: mode(NULL) evaluation (internal): -+--------+---------------------+ -| Column | Data | -+--------+---------------------+ -| a | Int64([4, 3, 2, 1]) | -| Output | Null { len: 2 } | -+--------+---------------------+ ++--------+-----------------------------+ +| Column | Data | ++--------+-----------------------------+ +| a | Column(Int64([4, 3, 2, 1])) | +| Output | Null { len: 2 } | ++--------+-----------------------------+ ast: mode(d) @@ -1648,19 +1782,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------+ -| d | UInt64([1, 1, 1, 1]) | +| d | Column(UInt64([1, 1, 1, 1])) | | Output | NullableColumn { column: UInt64([1, 1]), validity: [0b______11] } | +--------+-------------------------------------------------------------------+ ast: mode(all_null) evaluation (internal): -+----------+-------------------------------------------------------------------------+ -| Column | Data | -+----------+-------------------------------------------------------------------------+ -| all_null | NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] } | -| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | -+----------+-------------------------------------------------------------------------+ ++----------+---------------------------------------------------------------------------------+ +| Column | Data | ++----------+---------------------------------------------------------------------------------+ +| all_null | Column(NullableColumn { column: UInt64([1, 2, 3, 4]), validity: [0b____0000] }) | +| Output | NullableColumn { column: UInt64([0, 0]), validity: [0b______00] } | ++----------+---------------------------------------------------------------------------------+ ast: st_collect(to_geometry('point(10 20)')) @@ -1668,7 +1802,7 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x010400000004000000010100000000000000000024400000000000003440010100000000000000000024400000000000003440010100000000000000000024400000000000003440010100000000000000000024400000000000003440]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1678,19 +1812,19 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x0105000020e6100000040000000102000000020000000000000000002440000000000000344000000000000044400000000000004940010200000002000000000000000000244000000000000034400000000000004440000000000000494001020000000200000000000000000024400000000000003440000000000000444000000000000049400102000000020000000000000000002440000000000000344000000000000044400000000000004940]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ast: st_collect(NULL) evaluation (internal): -+--------+-------------------------------------------------------------------+ -| Column | Data | -+--------+-------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | -| Output | NullableColumn { column: Geometry([0x]), validity: [0b_______0] } | -+--------+-------------------------------------------------------------------+ ++--------+----------------------------------------------------------------------+ +| Column | Data | ++--------+----------------------------------------------------------------------+ +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | +| Output | NullableColumn { column: Geometry([0x]), validity: [0b_______0] } | ++--------+----------------------------------------------------------------------+ ast: st_collect(to_geometry(point)) @@ -1698,7 +1832,7 @@ evaluation (internal): +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point | StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)] | +| point | Column(StringColumn[POINT(1 1), POINT(2 2), POINT(3 3), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x0104000000040000000101000000000000000000f03f000000000000f03f010100000000000000000000400000000000000040010100000000000000000008400000000000000840010100000000000000000010400000000000001040]), validity: [0b_______1] } | +--------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1708,7 +1842,7 @@ evaluation (internal): +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point_null | NullableColumn { column: StringColumn[POINT(1 1), , POINT(3 3), POINT(4 4)], validity: [0b____1101] } | +| point_null | Column(NullableColumn { column: StringColumn[POINT(1 1), , POINT(3 3), POINT(4 4)], validity: [0b____1101] }) | | Output | NullableColumn { column: Geometry([0x0104000000030000000101000000000000000000f03f000000000000f03f010100000000000000000008400000000000000840010100000000000000000010400000000000001040]), validity: [0b_______1] } | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1718,7 +1852,7 @@ evaluation (internal): +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| line_string | StringColumn[LINESTRING(0 0, 1 1), LINESTRING(1 1, 2 2), LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)] | +| line_string | Column(StringColumn[LINESTRING(0 0, 1 1), LINESTRING(1 1, 2 2), LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)]) | | Output | NullableColumn { column: Geometry([0x01050000000400000001020000000200000000000000000000000000000000000000000000000000f03f000000000000f03f010200000002000000000000000000f03f000000000000f03f0000000000000040000000000000004001020000000200000000000000000000400000000000000040000000000000084000000000000008400102000000020000000000000000000840000000000000084000000000000010400000000000001040]), validity: [0b_______1] } | +-------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1728,7 +1862,7 @@ evaluation (internal): +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| line_string_null | NullableColumn { column: StringColumn[LINESTRING(0 0, 1 1), , LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)], validity: [0b____1101] } | +| line_string_null | Column(NullableColumn { column: StringColumn[LINESTRING(0 0, 1 1), , LINESTRING(2 2, 3 3), LINESTRING(3 3, 4 4)], validity: [0b____1101] }) | | Output | NullableColumn { column: Geometry([0x01050000000300000001020000000200000000000000000000000000000000000000000000000000f03f000000000000f03f01020000000200000000000000000000400000000000000040000000000000084000000000000008400102000000020000000000000000000840000000000000084000000000000010400000000000001040]), validity: [0b_______1] } | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1738,7 +1872,7 @@ evaluation (internal): +---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| polygon | StringColumn[POLYGON((0 0, 1 0, 1 1, 0 1, 0 0)), POLYGON((1 1, 2 1, 2 2, 1 2, 1 1)), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))] | +| polygon | Column(StringColumn[POLYGON((0 0, 1 0, 1 1, 0 1, 0 0)), POLYGON((1 1, 2 1, 2 2, 1 2, 1 1)), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))]) | | Output | NullableColumn { column: Geometry([0x0106000000040000000103000000010000000500000000000000000000000000000000000000000000000000f03f0000000000000000000000000000f03f000000000000f03f0000000000000000000000000000f03f0000000000000000000000000000000001030000000100000005000000000000000000f03f000000000000f03f0000000000000040000000000000f03f00000000000000400000000000000040000000000000f03f0000000000000040000000000000f03f000000000000f03f010300000001000000050000000000000000000040000000000000004000000000000008400000000000000040000000000000084000000000000008400000000000000040000000000000084000000000000000400000000000000040010300000001000000050000000000000000000840000000000000084000000000000010400000000000000840000000000000104000000000000010400000000000000840000000000000104000000000000008400000000000000840]), validity: [0b_______1] } | +---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1748,7 +1882,7 @@ evaluation (internal): +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| mixed_geom | StringColumn[POINT(0 0), LINESTRING(1 1, 2 2), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)] | +| mixed_geom | Column(StringColumn[POINT(0 0), LINESTRING(1 1, 2 2), POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)]) | | Output | NullableColumn { column: Geometry([0x010700000004000000010100000000000000000000000000000000000000010200000002000000000000000000f03f000000000000f03f00000000000000400000000000000040010300000001000000050000000000000000000040000000000000004000000000000008400000000000000040000000000000084000000000000008400000000000000040000000000000084000000000000000400000000000000040010100000000000000000010400000000000001040]), validity: [0b_______1] } | +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1758,7 +1892,7 @@ evaluation (internal): +-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| mixed_geom_null | NullableColumn { column: StringColumn[POINT(0 0), , POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)], validity: [0b____1101] } | +| mixed_geom_null | Column(NullableColumn { column: StringColumn[POINT(0 0), , POLYGON((2 2, 3 2, 3 3, 2 3, 2 2)), POINT(4 4)], validity: [0b____1101] }) | | Output | NullableColumn { column: Geometry([0x010700000003000000010100000000000000000000000000000000000000010300000001000000050000000000000000000040000000000000004000000000000008400000000000000040000000000000084000000000000008400000000000000040000000000000084000000000000000400000000000000040010100000000000000000010400000000000001040]), validity: [0b_______1] } | +-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1768,7 +1902,7 @@ evaluation (internal): +------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| point_4326 | StringColumn[SRID=4326;POINT(116.3 39.9), SRID=4326;POINT(121.4 31.2), SRID=4326;POINT(113.2 23.1), SRID=4326;POINT(114.1 22.5)] | +| point_4326 | Column(StringColumn[SRID=4326;POINT(116.3 39.9), SRID=4326;POINT(121.4 31.2), SRID=4326;POINT(113.2 23.1), SRID=4326;POINT(114.1 22.5)]) | | Output | NullableColumn { column: Geometry([0x0104000020e61000000400000001010000003333333333135d403333333333f3434001010000009a99999999595e403333333333333f400101000000cdcccccccc4c5c409a9999999919374001010000006666666666865c400000000000803640]), validity: [0b_______1] } | +------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1778,7 +1912,7 @@ evaluation (internal): +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| line_string_4326 | StringColumn[SRID=4326;LINESTRING(116.3 39.9, 121.4 31.2), SRID=4326;LINESTRING(121.4 31.2, 113.2 23.1), SRID=4326;LINESTRING(113.2 23.1, 114.1 22.5), SRID=4326;LINESTRING(114.1 22.5, 116.3 39.9)] | +| line_string_4326 | Column(StringColumn[SRID=4326;LINESTRING(116.3 39.9, 121.4 31.2), SRID=4326;LINESTRING(121.4 31.2, 113.2 23.1), SRID=4326;LINESTRING(113.2 23.1, 114.1 22.5), SRID=4326;LINESTRING(114.1 22.5, 116.3 39.9)]) | | Output | NullableColumn { column: Geometry([0x0105000020e6100000040000000102000000020000003333333333135d403333333333f343409a99999999595e403333333333333f400102000000020000009a99999999595e403333333333333f40cdcccccccc4c5c409a99999999193740010200000002000000cdcccccccc4c5c409a999999991937406666666666865c4000000000008036400102000000020000006666666666865c4000000000008036403333333333135d403333333333f34340]), validity: [0b_______1] } | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1788,7 +1922,7 @@ evaluation (internal): +--------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +--------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| polygon_4326 | StringColumn[SRID=4326;POLYGON((116 39, 117 39, 117 40, 116 40, 116 39)), SRID=4326;POLYGON((121 31, 122 31, 122 32, 121 32, 121 31)), SRID=4326;POLYGON((113 23, 114 23, 114 24, 113 24, 113 23)), SRID=4326;POLYGON((114 22, 115 22, 115 23, 114 23, 114 22))] | +| polygon_4326 | Column(StringColumn[SRID=4326;POLYGON((116 39, 117 39, 117 40, 116 40, 116 39)), SRID=4326;POLYGON((121 31, 122 31, 122 32, 121 32, 121 31)), SRID=4326;POLYGON((113 23, 114 23, 114 24, 113 24, 113 23)), SRID=4326;POLYGON((114 22, 115 22, 115 23, 114 23, 114 22))]) | | Output | NullableColumn { column: Geometry([0x0106000020e610000004000000010300000001000000050000000000000000005d4000000000008043400000000000405d4000000000008043400000000000405d4000000000000044400000000000005d4000000000000044400000000000005d400000000000804340010300000001000000050000000000000000405e400000000000003f400000000000805e400000000000003f400000000000805e4000000000000040400000000000405e4000000000000040400000000000405e400000000000003f40010300000001000000050000000000000000405c4000000000000037400000000000805c4000000000000037400000000000805c4000000000000038400000000000405c4000000000000038400000000000405c400000000000003740010300000001000000050000000000000000805c4000000000000036400000000000c05c4000000000000036400000000000c05c4000000000000037400000000000805c4000000000000037400000000000805c400000000000003640]), validity: [0b_______1] } | +--------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ @@ -1798,7 +1932,7 @@ evaluation (internal): +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Column | Data | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| mixed_3857 | StringColumn[SRID=3857;POINT(12947889.3 4852834.1), SRID=3857;LINESTRING(13515330.8 3642091.4, 12600089.2 2632873.5), SRID=3857;POLYGON((12700000 2600000, 12800000 2600000, 12800000 2700000, 12700000 2700000, 12700000 2600000)), SRID=3857;POINT(12959772.9 2551529.8)] | +| mixed_3857 | Column(StringColumn[SRID=3857;POINT(12947889.3 4852834.1), SRID=3857;LINESTRING(13515330.8 3642091.4, 12600089.2 2632873.5), SRID=3857;POLYGON((12700000 2600000, 12800000 2600000, 12800000 2700000, 12700000 2700000, 12700000 2600000)), SRID=3857;POINT(12959772.9 2551529.8)]) | | Output | NullableColumn { column: Geometry([0x0107000020110f00000400000001010000009a99992936b2684166666686188352410102000000020000009a99995948c76941333333b375c94b416666662663086841000000c05416444101030000000100000005000000000000002c3968410000000020d6434100000000006a68410000000020d6434100000000006a68410000000070994441000000002c3968410000000070994441000000002c3968410000000020d643410101000000cdcccc9c03b86841666666e674774341]), validity: [0b_______1] } | +------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ diff --git a/src/query/service/src/pipelines/processors/transforms/aggregator/aggregate_exchange_injector.rs b/src/query/service/src/pipelines/processors/transforms/aggregator/aggregate_exchange_injector.rs index 5c3663d0cc31b..bc244b9b93683 100644 --- a/src/query/service/src/pipelines/processors/transforms/aggregator/aggregate_exchange_injector.rs +++ b/src/query/service/src/pipelines/processors/transforms/aggregator/aggregate_exchange_injector.rs @@ -103,7 +103,7 @@ fn scatter_payload(mut payload: Payload, buckets: usize) -> Result> let probe_state = &*state.probe_state; for (bucket, (count, sel)) in buckets.iter_mut().zip(&probe_state.partition_entries) { if *count > 0 { - bucket.copy_rows(&sel[..*count], &state.addresses); + bucket.copy_rows(&sel[..*count as usize], &state.addresses); } } } @@ -152,7 +152,7 @@ pub fn scatter_partitioned_payload( .zip(&state.probe_state.partition_entries) { if *count > 0 { - bucket.copy_rows(&sel[..*count], &state.addresses); + bucket.copy_rows(&sel[..*count as usize], &state.addresses); } } } diff --git a/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_aggregate_partial.rs b/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_aggregate_partial.rs index 13c23f38ae23d..2154fd9c2c658 100644 --- a/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_aggregate_partial.rs +++ b/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_aggregate_partial.rs @@ -327,7 +327,6 @@ impl NewTransformPartialAggregate { .map(|index| index.is_agg) .unwrap_or_default(); - let block = block.consume_convert_to_full(); let group_columns = ProjectedBlock::project(&self.params.group_columns, &block); let rows_num = block.num_rows(); let block_bytes = block.memory_size(); diff --git a/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_final_aggregate.rs b/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_final_aggregate.rs index aff27102898b9..f41ec14819514 100644 --- a/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_final_aggregate.rs +++ b/src/query/service/src/pipelines/processors/transforms/aggregator/new_aggregate/new_transform_final_aggregate.rs @@ -142,7 +142,7 @@ impl NewFinalAggregateTransform { .zip(&state.partition_entries) { if *count > 0 { - payload.copy_rows(&sel[..*count], &flush_state.addresses); + payload.copy_rows(&sel[..*count as usize], &flush_state.addresses); } } } diff --git a/src/query/service/src/pipelines/processors/transforms/aggregator/transform_aggregate_partial.rs b/src/query/service/src/pipelines/processors/transforms/aggregator/transform_aggregate_partial.rs index 11bb79c0f44e1..8e76a2ddd1c40 100644 --- a/src/query/service/src/pipelines/processors/transforms/aggregator/transform_aggregate_partial.rs +++ b/src/query/service/src/pipelines/processors/transforms/aggregator/transform_aggregate_partial.rs @@ -127,7 +127,6 @@ impl TransformPartialAggregate { .map(|index| index.is_agg) .unwrap_or_default(); - let block = block.consume_convert_to_full(); let group_columns = ProjectedBlock::project(&self.params.group_columns, &block); let rows_num = block.num_rows(); diff --git a/src/query/service/src/pipelines/processors/transforms/aggregator/transform_single_key.rs b/src/query/service/src/pipelines/processors/transforms/aggregator/transform_single_key.rs index 500da0f6fdbdd..fff73a6e54303 100644 --- a/src/query/service/src/pipelines/processors/transforms/aggregator/transform_single_key.rs +++ b/src/query/service/src/pipelines/processors/transforms/aggregator/transform_single_key.rs @@ -101,7 +101,6 @@ impl AccumulatingTransform for PartialSingleStateAggregator { .and_then(AggIndexMeta::downcast_ref_from) .copied(); - let block = block.consume_convert_to_full(); if let Some(meta) = meta && meta.is_agg { @@ -230,7 +229,6 @@ impl AccumulatingTransform for FinalSingleStateAggregator { fn transform(&mut self, block: DataBlock) -> Result> { if !block.is_empty() { - let block = block.consume_convert_to_full(); self.to_merge_data.push(block); } diff --git a/src/query/service/src/pipelines/processors/transforms/window/partition/window_partition_exchange.rs b/src/query/service/src/pipelines/processors/transforms/window/partition/window_partition_exchange.rs index 9a240ca4b92a6..935d6d100c822 100644 --- a/src/query/service/src/pipelines/processors/transforms/window/partition/window_partition_exchange.rs +++ b/src/query/service/src/pipelines/processors/transforms/window/partition/window_partition_exchange.rs @@ -15,7 +15,7 @@ use std::sync::Arc; use databend_common_exception::Result; -use databend_common_expression::group_hash_columns; +use databend_common_expression::group_hash_entries; use databend_common_expression::DataBlock; use databend_common_expression::ProjectedBlock; use databend_common_pipeline::basic::Exchange; @@ -42,12 +42,11 @@ impl Exchange for WindowPartitionExchange { let num_rows = data_block.num_rows(); // Extract the columns used for hash computation. - let data_block = data_block.consume_convert_to_full(); let hash_cols = ProjectedBlock::project(&self.hash_keys, &data_block); // Compute the hash value for each row. let mut hashes = vec![0u64; num_rows]; - group_hash_columns(hash_cols, &mut hashes); + group_hash_entries(hash_cols, &mut hashes); // Scatter the data block to different partitions. let indices = hashes