centralize testutils

crates/rayexec_execution/src/arrays/array/mod.rs

@@ -831,7 +831,7 @@ mod tests {
     use super::*;
     use crate::arrays::compute::make_list::make_list_from_values;
     use crate::arrays::datatype::ListTypeMeta;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn try_new_constant_utf8() {

crates/rayexec_execution/src/arrays/batch.rs

@@ -363,7 +363,7 @@ mod tests {
     use stdutil::iter::TryFromExactSizeIterator;
 
     use super::*;
-    use crate::arrays::testutil::assert_batches_eq;
+    use crate::testutil::arrays::assert_batches_eq;
 
     #[test]
     fn new_from_other() {

crates/rayexec_execution/src/arrays/bitmap/mod.rs

@@ -5,8 +5,6 @@ use std::fmt;
 
 use rayexec_error::{RayexecError, Result};
 
-use crate::arrays::compute::util::IntoExtactSizeIterator;
-
 /// An LSB ordered bitmap.
 #[deprecated]
 #[derive(Clone, Default, PartialEq, Eq)]
@@ -315,15 +313,6 @@ impl Extend<bool> for Bitmap {
     }
 }
 
-impl<'a> IntoExtactSizeIterator for &'a Bitmap {
-    type Item = bool;
-    type IntoIter = BitmapIter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
 /// Iterator over individual bits (bools) in the bitmap.
 #[derive(Debug)]
 pub struct BitmapIter<'a> {

crates/rayexec_execution/src/arrays/compute/cast/array.rs

@@ -840,7 +840,7 @@ mod tests {
 
     use super::*;
     use crate::arrays::datatype::DecimalTypeMeta;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn array_cast_i32_to_i32() {

crates/rayexec_execution/src/arrays/compute/copy.rs

@@ -307,7 +307,7 @@ mod tests {
 
     use super::*;
     use crate::arrays::array::buffer_manager::NopBufferManager;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn copy_rows_simple() {

crates/rayexec_execution/src/arrays/compute/interleave.rs

@@ -2,6 +2,8 @@ use rayexec_error::Result;
 
 use crate::arrays::array::Array;
 
+// TODO: Remove?
+
 /// Interleave multiple arrays into one.
 ///
 /// Indices contains (array_idx, row_idx) pairs where 'row_idx' is the row
@@ -35,14 +37,13 @@ pub(crate) fn interleave(
 
 #[cfg(test)]
 mod tests {
-
 
     use stdutil::iter::TryFromExactSizeIterator;
 
     use super::*;
     use crate::arrays::array::buffer_manager::NopBufferManager;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn interleave_two_i32() {

crates/rayexec_execution/src/arrays/compute/mod.rs

@@ -5,5 +5,3 @@ pub mod date;
 pub mod hash;
 pub mod interleave;
 pub mod make_list;
-
-pub mod util;

crates/rayexec_execution/src/arrays/executor/scalar/binary.rs

@@ -164,7 +164,7 @@ mod tests {
     use crate::arrays::array::physical_type::{PhysicalI32, PhysicalUtf8};
     use crate::arrays::array::Array;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn binary_simple_add() {

crates/rayexec_execution/src/arrays/executor/scalar/ternary.rs

@@ -205,7 +205,7 @@ mod tests {
     use crate::arrays::array::buffer_manager::NopBufferManager;
     use crate::arrays::array::physical_type::{PhysicalI32, PhysicalUtf8};
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn ternary_left_prepend_simple() {

crates/rayexec_execution/src/arrays/executor/scalar/unary.rs

@@ -230,7 +230,7 @@ mod tests {
     };
     use crate::arrays::array::Array;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn int32_inc_by_2() {

crates/rayexec_execution/src/arrays/executor/scalar/uniform.rs

@@ -155,7 +155,7 @@ mod tests {
     use crate::arrays::array::buffer_manager::NopBufferManager;
     use crate::arrays::array::physical_type::{PhysicalBool, PhysicalUtf8};
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn uniform_and_simple() {

crates/rayexec_execution/src/arrays/mod.rs

@@ -13,5 +13,3 @@ pub mod scalar;
 pub mod selection;
 pub mod sort;
 pub mod string;
-
-pub mod testutil;

crates/rayexec_execution/src/arrays/row/aggregate_collection.rs

@@ -1,15 +1,25 @@
 use std::borrow::Borrow;
+use std::collections::VecDeque;
 
 use rayexec_error::{RayexecError, Result};
 use stdutil::iter::IntoExactSizeIterator;
 
 use super::aggregate_layout::AggregateLayout;
 use super::block::ValidityInitializer;
+use super::block_scanner::BlockScanState;
 use super::row_blocks::{BlockAppendState, RowBlocks};
 use crate::arrays::array::buffer_manager::NopBufferManager;
 use crate::arrays::array::Array;
 use crate::functions::aggregate::states::AggregateFunctionImpl;
 
+#[derive(Debug)]
+pub struct AggregateScanState {
+    blocks_to_scan: VecDeque<usize>,
+    current_block: Option<usize>,
+    row_idx: usize,
+    block_read: BlockScanState,
+}
+
 #[derive(Debug)]
 pub struct AggregateAppendState {
     /// State for appending to row/heap blocks.

crates/rayexec_execution/src/arrays/row/row_collection.rs

@@ -306,7 +306,7 @@ mod tests {
 
     use super::*;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::{assert_arrays_eq, assert_batches_eq, generate_batch};
+    use crate::testutil::arrays::{assert_arrays_eq, assert_batches_eq, generate_batch};
 
     #[test]
     fn append_single_batch_i32() {

crates/rayexec_execution/src/arrays/row/row_layout.rs

@@ -625,7 +625,7 @@ mod tests {
     use super::*;
     use crate::arrays::array::buffer_manager::NopBufferManager;
     use crate::arrays::row::row_blocks::RowBlocks;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn new_empty() {

crates/rayexec_execution/src/arrays/row/row_matcher.rs

@@ -357,7 +357,7 @@ mod tests {
     use super::*;
     use crate::arrays::datatype::DataType;
     use crate::arrays::row::row_collection::RowCollection;
-    use crate::arrays::testutil::generate_batch;
+    use crate::testutil::arrays::generate_batch;
 
     #[test]
     fn match_single_i32_eq() {

crates/rayexec_execution/src/arrays/scalar/mod.rs

@@ -503,7 +503,7 @@ mod tests {
     use stdutil::iter::TryFromExactSizeIterator;
 
     use super::*;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     #[test]
     fn scalar_i32_as_array() {

crates/rayexec_execution/src/arrays/sort/binary_merge.rs

@@ -511,7 +511,7 @@ mod tests {
     use crate::arrays::array::buffer_manager::NopBufferManager;
     use crate::arrays::batch::Batch;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::{assert_batches_eq, generate_batch, TestSortedRowBlock};
+    use crate::testutil::arrays::{assert_batches_eq, generate_batch, TestSortedRowBlock};
 
     /// Helper that will binary merge left and right, returning the result.
     ///

crates/rayexec_execution/src/arrays/sort/partial_sort.rs

@@ -243,7 +243,7 @@ mod tests {
     use crate::arrays::datatype::DataType;
     use crate::arrays::row::block_scanner::BlockScanState;
     use crate::arrays::sort::sort_layout::SortColumn;
-    use crate::arrays::testutil::assert_arrays_eq;
+    use crate::testutil::arrays::assert_arrays_eq;
 
     /// Helper for asserting that key/data inputs sort correctly with the
     /// resulting data matching `expected`.

crates/rayexec_execution/src/arrays/sort/sorted_run.rs

@@ -105,7 +105,7 @@ where
 mod tests {
     use super::*;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::{assert_batches_eq, generate_batch, TestSortedRowBlock};
+    use crate::testutil::arrays::{assert_batches_eq, generate_batch, TestSortedRowBlock};
 
     #[test]
     fn scan_data_single_block_exact_capacity() {

crates/rayexec_execution/src/execution/executable/planner.rs

@@ -447,10 +447,10 @@ mod tests {
     use super::*;
     use crate::arrays::datatype::DataType;
     use crate::execution::operators::project::PhysicalProject;
-    use crate::execution::operators::testutil::test_database_context;
     use crate::execution::operators::union::PhysicalUnion;
     use crate::execution::operators::values::PhysicalValues;
     use crate::expr::physical::literal_expr::PhysicalLiteralExpr;
+    use crate::testutil::database_context::test_database_context;
 
     #[test]
     fn plan_single_pipeline() {

crates/rayexec_execution/src/execution/operators/empty.rs

@@ -79,14 +79,14 @@ impl DatabaseProtoConv for PhysicalEmpty {
 
 #[cfg(test)]
 mod tests {
-
 
     use super::*;
     use crate::arrays::array::buffer_manager::NopBufferManager;
     use crate::arrays::array::Array;
     use crate::arrays::batch::Batch;
     use crate::arrays::datatype::DataType;
-    use crate::execution::operators::testutil::{test_database_context, OperatorWrapper};
+    use crate::testutil::database_context::test_database_context;
+    use crate::testutil::operator::OperatorWrapper;
 
     #[test]
     fn empty_simple() {

crates/rayexec_execution/src/execution/operators/filter.rs

@@ -102,9 +102,10 @@ mod tests {
     use crate::arrays::array::Array;
     use crate::arrays::batch::Batch;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_batches_eq;
-    use crate::execution::operators::testutil::{test_database_context, OperatorWrapper};
     use crate::expr::physical::column_expr::PhysicalColumnExpr;
+    use crate::testutil::arrays::assert_batches_eq;
+    use crate::testutil::database_context::test_database_context;
+    use crate::testutil::operator::OperatorWrapper;
 
     #[test]
     fn filter_simple() {

crates/rayexec_execution/src/execution/operators/hash_aggregate/aggregate_hash_table.rs

@@ -87,13 +87,19 @@ impl AggregateHashTable {
         debug_assert!(!state.row_ptrs.iter().any(|ptr| ptr.is_null()));
 
         // Update states.
-        unimplemented!()
-        // unsafe {
-        //     self.data
-        //         .update_aggregates(&state.row_ptrs, inputs, 0..num_rows)?;
-        // }
+        let agg_inputs: Vec<_> = self
+            .layout
+            .aggregates
+            .iter()
+            .flat_map(|agg| agg.columns.iter().map(|col| inputs[col.idx]))
+            .collect();
+
+        unsafe {
+            self.layout
+                .update_states(state.row_ptrs.as_mut_slice(), &agg_inputs, num_rows)?;
+        }
 
-        // Ok(())
+        Ok(())
     }
 
     /// Find or create groups in the hash table.
@@ -259,6 +265,18 @@ impl AggregateHashTable {
         Ok(())
     }
 
+    pub fn merge_from(&mut self, state: &mut InsertState, other: &mut Self) -> Result<()> {
+        if self.directory.num_occupied == 0 {
+            std::mem::swap(self, other);
+            return Ok(());
+        }
+        if other.directory.num_occupied == 0 {
+            return Ok(());
+        }
+
+        unimplemented!()
+    }
+
     /// Get the hash for a row.
     ///
     /// Safety:

crates/rayexec_execution/src/execution/operators/hash_join/join_hash_table.rs

@@ -545,7 +545,7 @@ pub struct BuildState {
 mod tests {
 
     use super::*;
-    use crate::arrays::testutil::{assert_batches_eq, generate_batch};
+    use crate::testutil::arrays::{assert_batches_eq, generate_batch};
 
     #[test]
     fn inner_join_single_eq_predicate() {

crates/rayexec_execution/src/execution/operators/join/cross_product.rs

@@ -84,7 +84,7 @@ mod tests {
     use super::*;
     use crate::arrays::array::Array;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_batches_eq;
+    use crate::testutil::arrays::assert_batches_eq;
 
     #[test]
     fn cross_product_single_collected_batch() {

crates/rayexec_execution/src/execution/operators/join/nested_loop_join.rs

@@ -337,9 +337,10 @@ impl Explainable for PhysicalNestedLoopJoin {
 mod tests {
     use super::*;
     use crate::arrays::batch::Batch;
-    use crate::arrays::testutil::{assert_batches_eq, generate_batch};
-    use crate::execution::operators::testutil::{plan_scalar, OperatorWrapper};
     use crate::expr;
+    use crate::testutil::arrays::{assert_batches_eq, generate_batch};
+    use crate::testutil::exprs::plan_scalar;
+    use crate::testutil::operator::OperatorWrapper;
 
     #[test]
     fn cross_join_single_build_batch_single_partition() {

crates/rayexec_execution/src/execution/operators/join/outer_join_tracker.rs

@@ -76,7 +76,7 @@ mod tests {
     use super::*;
     use crate::arrays::array::Array;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::assert_batches_eq;
+    use crate::testutil::arrays::assert_batches_eq;
 
     #[test]
     fn right_join_none_match() {

crates/rayexec_execution/src/execution/operators/limit.rs

@@ -169,8 +169,8 @@ mod tests {
     use super::*;
     use crate::arrays::batch::Batch;
     use crate::arrays::datatype::DataType;
-    use crate::arrays::testutil::{assert_batches_eq, generate_batch};
-    use crate::execution::operators::testutil::OperatorWrapper;
+    use crate::testutil::arrays::{assert_batches_eq, generate_batch};
+    use crate::testutil::operator::OperatorWrapper;
 
     #[test]
     fn limit_no_offset_simple() {