wip

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

fuzz/src/file/mod.rs

@@ -4,8 +4,8 @@
 use libfuzzer_sys::arbitrary::{Arbitrary, Unstructured};
 use vortex_array::ArrayRef;
 use vortex_array::arrays::arbitrary::ArbitraryArray;
-use vortex_expr::Expression;
-use vortex_expr::arbitrary::{filter_expr, projection_expr};
+use vortex_array::expr::Expression;
+use vortex_array::expr::arbitrary::{filter_expr, projection_expr};
 
 use crate::array::CompressorStrategy;
 

vortex-array/benches/expr/large_struct_pack.rs

@@ -4,8 +4,8 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
+use vortex_array::expr::{get_item, pack, root};
 use vortex_dtype::{DType, FieldName, Nullability, PType, StructFields};
-use vortex_expr::{get_item, pack, root};
 
 fn main() {
     divan::main();

vortex-array/src/expr/expression.rs

@@ -10,9 +10,9 @@ use std::sync::Arc;
 use vortex_dtype::{DType, FieldPath};
 use vortex_error::{VortexExpect, VortexResult};
 
+use crate::ArrayRef;
 use crate::expr::display::DisplayTreeExpr;
 use crate::expr::{ChildName, ExprId, ExprVTable, ExpressionView, StatsCatalog, VTable};
-use crate::{ArrayRef, display};
 
 /// A node in a Vortex expression tree.
 ///
@@ -215,10 +215,10 @@ impl Expression {
     /// # Example
     ///
     /// ```rust
-    /// # use crate::compute::LikeOptions;
-    /// # use crate::vortex_expr::VTableExt;
+    /// # use vortex_array::compute::LikeOptions;
+    /// # use vortex_array::expr::VTableExt;
     /// # use vortex_dtype::{DType, Nullability, PType};
-    /// # use vortex_expr::{and, cast, eq, get_item, gt, lit, not, root, select, Like};
+    /// # use vortex_array::expr::{and, cast, eq, get_item, gt, lit, not, root, select, Like};
     /// // Build a complex nested expression
     /// let complex_expr = select(
     ///     ["result"],

vortex-array/src/expr/exprs/between.rs

@@ -9,12 +9,12 @@ use vortex_dtype::DType::Bool;
 use vortex_error::{VortexExpect, VortexResult, vortex_bail};
 use vortex_proto::expr as pb;
 
+use crate::ArrayRef;
 use crate::compute::{BetweenOptions, between as between_compute};
 use crate::expr::expression::Expression;
 use crate::expr::exprs::binary::Binary;
 use crate::expr::exprs::operators::Operator;
-use crate::{ArrayRef};
-use crate::expr::{ChildName, ExprId, ExpressionView, StatsCatalog, VTable, VTableExt}
+use crate::expr::{ChildName, ExprId, ExpressionView, StatsCatalog, VTable, VTableExt};
 
 /// An optimized scalar expression to compute whether values fall between two bounds.
 ///
@@ -50,14 +50,14 @@ impl VTable for Between {
         let opts = pb::BetweenOpts::decode(metadata)?;
         Ok(Some(BetweenOptions {
             lower_strict: if opts.lower_strict {
-                vortex_array::compute::StrictComparison::Strict
+                crate::compute::StrictComparison::Strict
             } else {
-                vortex_array::compute::StrictComparison::NonStrict
+                crate::compute::StrictComparison::NonStrict
             },
             upper_strict: if opts.upper_strict {
-                vortex_array::compute::StrictComparison::Strict
+                crate::compute::StrictComparison::Strict
             } else {
-                vortex_array::compute::StrictComparison::NonStrict
+                crate::compute::StrictComparison::NonStrict
             },
         }))
     }
@@ -179,9 +179,9 @@ impl ExpressionView<'_, Between> {
 /// The comparison strictness is controlled by the options parameter.
 ///
 /// ```rust
-/// # use crate::compute::BetweenOptions;
-/// # use crate::compute::StrictComparison;
-/// # use vortex_expr::{between, lit, root};
+/// # use vortex_array::compute::BetweenOptions;
+/// # use vortex_array::compute::StrictComparison;
+/// # use vortex_array::expr::{between, lit, root};
 /// let opts = BetweenOptions {
 ///     lower_strict: StrictComparison::NonStrict,
 ///     upper_strict: StrictComparison::NonStrict,

vortex-array/src/expr/exprs/binary.rs

@@ -12,9 +12,8 @@ use crate::compute::{add, and_kleene, compare, div, mul, or_kleene, sub};
 use crate::expr::expression::Expression;
 use crate::expr::exprs::literal::lit;
 use crate::expr::exprs::operators::Operator;
-use crate::{
-    ArrayRef, ChildName, ExprId, ExpressionView, StatsCatalog, VTable, VTableExt, compute,
-};
+use crate::expr::{ChildName, ExprId, ExpressionView, StatsCatalog, VTable, VTableExt};
+use crate::{ArrayRef, compute};
 
 pub struct Binary;
 
@@ -259,11 +258,11 @@ impl ExpressionView<'_, Binary> {
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::{BoolArray, PrimitiveArray };
-/// # use crate::{Array, IntoArray, ToCanonical};
-/// # use crate::validity::Validity;
+/// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
+/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
-/// # use vortex_expr::{eq, root, lit};
+/// # use vortex_array::expr::{eq, root, lit};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
 /// let result = eq(root(), lit(3)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -283,11 +282,11 @@ pub fn eq(lhs: Expression, rhs: Expression) -> Expression {
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::{BoolArray, PrimitiveArray };
-/// # use crate::{IntoArray, ToCanonical};
-/// # use crate::validity::Validity;
+/// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
+/// # use vortex_array::{IntoArray, ToCanonical};
+/// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
-/// # use vortex_expr::{root, lit, not_eq};
+/// # use vortex_array::expr::{root, lit, not_eq};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
 /// let result = not_eq(root(), lit(3)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -307,11 +306,11 @@ pub fn not_eq(lhs: Expression, rhs: Expression) -> Expression {
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::{BoolArray, PrimitiveArray };
-/// # use crate::{IntoArray, ToCanonical};
-/// # use crate::validity::Validity;
+/// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
+/// # use vortex_array::{IntoArray, ToCanonical};
+/// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
-/// # use vortex_expr::{gt_eq, root, lit};
+/// # use vortex_array::expr::{gt_eq, root, lit};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
 /// let result = gt_eq(root(), lit(3)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -331,11 +330,11 @@ pub fn gt_eq(lhs: Expression, rhs: Expression) -> Expression {
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::{BoolArray, PrimitiveArray };
-/// # use crate::{IntoArray, ToCanonical};
-/// # use crate::validity::Validity;
+/// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
+/// # use vortex_array::{IntoArray, ToCanonical};
+/// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
-/// # use vortex_expr::{gt, root, lit};
+/// # use vortex_array::expr::{gt, root, lit};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
 /// let result = gt(root(), lit(2)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -355,11 +354,11 @@ pub fn gt(lhs: Expression, rhs: Expression) -> Expression {
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::{BoolArray, PrimitiveArray };
-/// # use crate::{IntoArray, ToCanonical};
-/// # use crate::validity::Validity;
+/// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
+/// # use vortex_array::{IntoArray, ToCanonical};
+/// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
-/// # use vortex_expr::{root, lit, lt_eq};
+/// # use vortex_array::expr::{root, lit, lt_eq};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
 /// let result = lt_eq(root(), lit(2)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -379,11 +378,11 @@ pub fn lt_eq(lhs: Expression, rhs: Expression) -> Expression {
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::{BoolArray, PrimitiveArray };
-/// # use crate::{IntoArray, ToCanonical};
-/// # use crate::validity::Validity;
+/// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
+/// # use vortex_array::{IntoArray, ToCanonical};
+/// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
-/// # use vortex_expr::{root, lit, lt};
+/// # use vortex_array::expr::{root, lit, lt};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
 /// let result = lt(root(), lit(3)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -403,9 +402,9 @@ pub fn lt(lhs: Expression, rhs: Expression) -> Expression {
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::BoolArray;
-/// # use crate::{IntoArray, ToCanonical};
-/// # use vortex_expr::{root, lit, or};
+/// # use vortex_array::arrays::BoolArray;
+/// # use vortex_array::{IntoArray, ToCanonical};
+/// # use vortex_array::expr::{root, lit, or};
 /// let xs = BoolArray::from_iter(vec![true, false, true]);
 /// let result = or(root(), lit(false)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -437,9 +436,9 @@ where
 /// ## Example usage
 ///
 /// ```
-/// # use crate::arrays::BoolArray;
-/// # use crate::{IntoArray, ToCanonical};
-/// # use vortex_expr::{and, root, lit};
+/// # use vortex_array::arrays::BoolArray;
+/// # use vortex_array::{IntoArray, ToCanonical};
+/// # use vortex_array::expr::{and, root, lit};
 /// let xs = BoolArray::from_iter(vec![true, false, true]);
 /// let result = and(root(), lit(true)).evaluate(&xs.to_array()).unwrap();
 ///
@@ -481,10 +480,10 @@ where
 /// ## Example usage
 ///
 /// ```
-/// # use crate::IntoArray;
-/// # use crate::arrow::IntoArrowArray as _;
+/// # use vortex_array::IntoArray;
+/// # use vortex_array::arrow::IntoArrowArray as _;
 /// # use vortex_buffer::buffer;
-/// # use vortex_expr::{checked_add, lit, root};
+/// # use vortex_array::expr::{checked_add, lit, root};
 /// let xs = buffer![1, 2, 3].into_array();
 /// let result = checked_add(root(), lit(5))
 ///     .evaluate(&xs.to_array())
@@ -511,7 +510,7 @@ mod tests {
     use super::{and, and_collect, and_collect_right, eq, gt, gt_eq, lt, lt_eq, not_eq, or};
     use crate::expr::exprs::get_item::col;
     use crate::expr::exprs::literal::lit;
-    use crate::{Expression, test_harness};
+    use crate::expr::{Expression, test_harness};
 
     #[test]
     fn and_collect_left_assoc() {

vortex-array/src/expr/exprs/cast.rs

@@ -9,9 +9,10 @@ use vortex_dtype::{DType, FieldPath};
 use vortex_error::{VortexExpect, VortexResult, vortex_bail, vortex_err};
 use vortex_proto::expr as pb;
 
+use crate::ArrayRef;
 use crate::compute::cast as compute_cast;
 use crate::expr::expression::Expression;
-use crate::{ArrayRef, ChildName, ExprId, ExpressionView, StatsCatalog, VTable, VTableExt};
+use crate::expr::{ChildName, ExprId, ExpressionView, StatsCatalog, VTable, VTableExt};
 
 /// A cast expression that converts values to a target data type.
 pub struct Cast;
@@ -120,7 +121,7 @@ impl VTable for Cast {
 ///
 /// ```rust
 /// # use vortex_dtype::{DType, Nullability, PType};
-/// # use vortex_expr::{cast, root};
+/// # use vortex_array::expr::{cast, root};
 /// let expr = cast(root(), DType::Primitive(PType::I64, Nullability::NonNullable));
 /// ```
 pub fn cast(child: Expression, target: DType) -> Expression {
@@ -138,7 +139,9 @@ mod tests {
     use crate::arrays::StructArray;
     use crate::expr::exprs::get_item::get_item;
     use crate::expr::exprs::root::root;
-    use crate::{Expression, IntoArray, test_harness};
+    use crate::expr::Expression;
+    use crate::expr::test_harness;
+    use crate::IntoArray;
 
     #[test]
     fn dtype() {

vortex-array/src/expr/exprs/dynamic.rs

@@ -13,10 +13,8 @@ use vortex_scalar::{Scalar, ScalarValue};
 use crate::arrays::ConstantArray;
 use crate::compute::{Operator, compare};
 use crate::expr::traversal::{NodeExt, NodeVisitor, TraversalOrder};
-use crate::{
-    Array, ArrayRef, ChildName, ExprId, Expression, ExpressionView, IntoArray, StatsCatalog,
-    VTable, VTableExt,
-};
+use crate::expr::{ChildName, ExprId, Expression, ExpressionView, StatsCatalog, VTable, VTableExt};
+use crate::{Array, ArrayRef, IntoArray};
 
 /// A dynamic comparison expression can be used to capture a comparison to a value that can change
 /// during the execution of a query, such as when a compute engine pushes down an ORDER BY + LIMIT

vortex-array/src/expr/exprs/get_item.rs

@@ -11,11 +11,9 @@ use vortex_proto::expr as pb;
 
 use crate::compute::mask;
 use crate::expr::exprs::root::root;
+use crate::expr::{ChildName, ExprId, Expression, ExpressionView, StatsCatalog, VTable, VTableExt};
 use crate::stats::Stat;
-use crate::{
-    ArrayRef,  ToCanonical,
-};
-use crate::expr::{ChildName, ExprId, Expression, ExpressionView, StatsCatalog,VTable, VTableExt}
+use crate::{ArrayRef, ToCanonical};
 
 pub struct GetItem;
 
@@ -132,7 +130,7 @@ impl VTable for GetItem {
 /// Equivalent to `get_item(field, root())` - extracts a named field from the input array.
 ///
 /// ```rust
-/// # use vortex_expr::col;
+/// # use vortex_array::expr::col;
 /// let expr = col("name");
 /// ```
 pub fn col(field: impl Into<FieldName>) -> Expression {
@@ -144,7 +142,7 @@ pub fn col(field: impl Into<FieldName>) -> Expression {
 /// Accesses the specified field from the result of the child expression.
 ///
 /// ```rust
-/// # use vortex_expr::{get_item, root};
+/// # use vortex_array::expr::{get_item, root};
 /// let expr = get_item("user_id", root());
 /// ```
 pub fn get_item(field: impl Into<FieldName>, child: Expression) -> Expression {

vortex-array/src/expr/exprs/is_null.rs

@@ -11,11 +11,9 @@ use vortex_mask::Mask;
 use crate::arrays::{BoolArray, ConstantArray};
 use crate::expr::exprs::binary::eq;
 use crate::expr::exprs::literal::lit;
+use crate::expr::{ChildName, ExprId, Expression, ExpressionView, StatsCatalog, VTable, VTableExt};
 use crate::stats::Stat;
-use crate::{
-    Array, ArrayRef, ChildName, ExprId, Expression, ExpressionView, IntoArray, StatsCatalog,
-    VTable, VTableExt,
-};
+use crate::{Array, ArrayRef, IntoArray};
 
 /// Expression that checks for null values.
 pub struct IsNull;
@@ -87,7 +85,7 @@ impl VTable for IsNull {
 /// Returns a boolean array indicating which positions contain null values.
 ///
 /// ```rust
-/// # use vortex_expr::{is_null, root};
+/// # use vortex_array::expr::{is_null, root};
 /// let expr = is_null(root());
 /// ```
 pub fn is_null(child: Expression) -> Expression {
@@ -108,9 +106,11 @@ mod tests {
     use crate::expr::exprs::get_item::{col, get_item};
     use crate::expr::exprs::literal::lit;
     use crate::expr::exprs::root::root;
-    use crate::pruning::checked_pruning_expr;
+    use crate::expr::pruning::checked_pruning_expr;
+    use crate::expr::test_harness;
     use crate::stats::Stat;
-    use crate::{HashSet, IntoArray, test_harness};
+    use crate::IntoArray;
+    use vortex_utils::aliases::hash_set::HashSet;
 
     #[test]
     fn dtype() {

vortex-array/src/expr/exprs/like.rs

@@ -8,8 +8,9 @@ use vortex_dtype::DType;
 use vortex_error::{VortexResult, vortex_bail};
 use vortex_proto::expr as pb;
 
+use crate::ArrayRef;
 use crate::compute::{LikeOptions, like as like_compute};
-use crate::{ArrayRef, ChildName, ExprId, Expression, ExpressionView, VTable, VTableExt};
+use crate::expr::{ChildName, ExprId, Expression, ExpressionView, VTable, VTableExt};
 
 /// Expression that performs SQL LIKE pattern matching.
 pub struct Like;