Overtime events

Author: gatesn

vortex-array/src/compute/between.rs

@@ -6,13 +6,13 @@ use std::sync::LazyLock;
 
 use arcref::ArcRef;
 use vortex_dtype::DType;
-use vortex_error::{vortex_bail, vortex_err, VortexError, VortexExpect, VortexResult};
+use vortex_error::{VortexError, VortexExpect, VortexResult, vortex_bail, vortex_err};
 use vortex_scalar::Scalar;
 
 use crate::arrays::ConstantArray;
 use crate::compute::{
-    boolean, compare, BooleanOperator, ComputeFn, ComputeFnVTable, InvocationArgs, Kernel, Operator,
-    Options, Output,
+    BooleanOperator, ComputeFn, ComputeFnVTable, InvocationArgs, Kernel, Operator, Options, Output,
+    boolean, compare,
 };
 use crate::vtable::VTable;
 use crate::{Array, ArrayRef, Canonical, IntoArray};
@@ -274,9 +274,9 @@ mod tests {
     use vortex_dtype::{Nullability, PType};
 
     use super::*;
+    use crate::ToCanonical;
     use crate::compute::conformance::search_sorted::rstest;
     use crate::test_harness::to_int_indices;
-    use crate::ToCanonical;
 
     #[rstest]
     #[case(StrictComparison::NonStrict, StrictComparison::NonStrict, vec![0, 1, 2, 3])]

vortex-array/src/compute/like.rs

@@ -6,9 +6,9 @@ use std::sync::LazyLock;
 
 use arcref::ArcRef;
 use vortex_dtype::DType;
-use vortex_error::{vortex_bail, vortex_err, VortexError, VortexExpect, VortexResult};
+use vortex_error::{VortexError, VortexExpect, VortexResult, vortex_bail, vortex_err};
 
-use crate::arrow::{from_arrow_array_with_len, Datum};
+use crate::arrow::{Datum, from_arrow_array_with_len};
 use crate::compute::{ComputeFn, ComputeFnVTable, InvocationArgs, Kernel, Options, Output};
 use crate::vtable::VTable;
 use crate::{Array, ArrayRef};

vortex-datafusion/src/convert/exprs.rs

@@ -7,16 +7,16 @@ use arrow_schema::{DataType, Schema};
 use datafusion_expr::Operator as DFOperator;
 use datafusion_functions::core::getfield::GetFieldFunc;
 use datafusion_physical_expr::{PhysicalExpr, ScalarFunctionExpr};
-use datafusion_physical_expr_common::physical_expr::{is_dynamic_physical_expr, PhysicalExprRef};
+use datafusion_physical_expr_common::physical_expr::{PhysicalExprRef, is_dynamic_physical_expr};
 use datafusion_physical_plan::expressions as df_expr;
 use itertools::Itertools;
 use vortex::compute::LikeOptions;
 use vortex::dtype::arrow::FromArrowType;
 use vortex::dtype::{DType, Nullability};
-use vortex::error::{vortex_bail, vortex_err, VortexResult};
+use vortex::error::{VortexResult, vortex_bail, vortex_err};
 use vortex::expr::{
-    and, cast, get_item, is_null, list_contains, lit, not, root, Binary, Expression,
-    Like, Operator, VTableExt,
+    Binary, Expression, Like, Operator, VTableExt, and, cast, get_item, is_null, list_contains,
+    lit, not, root,
 };
 use vortex::scalar::Scalar;
 
@@ -43,7 +43,7 @@ impl TryFromDataFusion<dyn PhysicalExpr> for Expression {
             let right = Expression::try_from_df(binary_expr.right().as_ref())?;
             let operator = Operator::try_from_df(binary_expr.op())?;
 
-            return Ok(Binary.new(operator, [left, right]));
+            return Ok(Binary.new_expr(operator, [left, right]));
         }
 
         if let Some(col_expr) = df.as_any().downcast_ref::<df_expr::Column>() {
@@ -53,7 +53,7 @@ impl TryFromDataFusion<dyn PhysicalExpr> for Expression {
         if let Some(like) = df.as_any().downcast_ref::<df_expr::LikeExpr>() {
             let child = Expression::try_from_df(like.expr().as_ref())?;
             let pattern = Expression::try_from_df(like.pattern().as_ref())?;
-            return Ok(Like.new(
+            return Ok(Like.new_expr(
                 LikeOptions {
                     negated: like.negated(),
                     case_insensitive: like.case_insensitive(),
@@ -283,8 +283,8 @@ mod tests {
 
     use arrow_schema::{DataType, Field, Fields, Schema, TimeUnit as ArrowTimeUnit};
     use datafusion::functions::core::getfield::GetFieldFunc;
-    use datafusion_common::config::ConfigOptions;
     use datafusion_common::ScalarValue;
+    use datafusion_common::config::ConfigOptions;
     use datafusion_expr::{Operator as DFOperator, ScalarUDF};
     use datafusion_physical_expr::PhysicalExpr;
     use datafusion_physical_plan::expressions as df_expr;
@@ -404,7 +404,7 @@ mod tests {
         assert_snapshot!(result.display_tree().to_string(), @r#"
         vortex.binary =
         ├── lhs: vortex.get_item "left"
-        │   └── input: vortex.root 
+        │   └── input: vortex.root
         └── rhs: vortex.literal 42i32
         "#);
     }
@@ -427,7 +427,7 @@ mod tests {
             assert_snapshot!(result.display_tree().to_string(), @r#"
             vortex.like LikeOptions { negated: false, case_insensitive: false }
             ├── child: vortex.get_item "text_col"
-            │   └── input: vortex.root 
+            │   └── input: vortex.root
             └── pattern: vortex.literal "test%"
             "#);
         }

vortex-duckdb/src/convert/expr.rs

@@ -6,10 +6,10 @@ use std::sync::Arc;
 use itertools::Itertools;
 use vortex::compute::{BetweenOptions, LikeOptions, StrictComparison};
 use vortex::dtype::Nullability;
-use vortex::error::{vortex_bail, vortex_err, VortexError, VortexExpect, VortexResult};
+use vortex::error::{VortexError, VortexExpect, VortexResult, vortex_bail, vortex_err};
 use vortex::expr::{
-    and_collect, col, is_null, list_contains, lit, not, or_collect, Between, Binary, Expression,
-    Like, Literal, Operator, VTableExt,
+    Between, Binary, Expression, Like, Literal, Operator, VTableExt, and_collect, col, is_null,
+    list_contains, lit, not, or_collect,
 };
 use vortex::scalar::Scalar;
 
@@ -49,7 +49,7 @@ pub fn try_from_bound_expression(value: &duckdb::Expression) -> VortexResult<Opt
                 return Ok(None);
             };
 
-            Binary.new(operator, [left, right])
+            Binary.new_expr(operator, [left, right])
         }
         duckdb::ExpressionClass::BoundBetween(between) => {
             let Some(array) = try_from_bound_expression(&between.input)? else {
@@ -61,7 +61,7 @@ pub fn try_from_bound_expression(value: &duckdb::Expression) -> VortexResult<Opt
             let Some(upper) = try_from_bound_expression(&between.upper)? else {
                 return Ok(None);
             };
-            Between.new(
+            Between.new_expr(
                 BetweenOptions {
                     lower_strict: if between.lower_inclusive {
                         StrictComparison::NonStrict
@@ -144,7 +144,7 @@ pub fn try_from_bound_expression(value: &duckdb::Expression) -> VortexResult<Opt
                     vortex_bail!("expected pattern to be bound string")
                 };
                 let pattern = lit(pattern_lit);
-                Like.new(LikeOptions::default(), [value, pattern])
+                Like.new_expr(LikeOptions::default(), [value, pattern])
             }
             _ => {
                 log::debug!("bound function {}", func.scalar_function.name());

vortex-duckdb/src/convert/table_filter.rs

@@ -6,10 +6,10 @@ use std::sync::Arc;
 use itertools::Itertools;
 use vortex::compute::Operator;
 use vortex::dtype::{DType, Nullability};
-use vortex::error::{vortex_bail, VortexExpect, VortexResult};
+use vortex::error::{VortexExpect, VortexResult, vortex_bail};
 use vortex::expr::{
-    and_collect, get_item, is_null, list_contains, lit, not, or_collect, Binary, Expression,
-    VTableExt,
+    Binary, Expression, VTableExt, and_collect, get_item, is_null, list_contains, lit, not,
+    or_collect,
 };
 use vortex::scalar::Scalar;
 
@@ -25,7 +25,7 @@ pub fn try_from_table_filter(
         TableFilterClass::ConstantComparison(const_) => {
             let scalar: Scalar = const_.value.try_into()?;
 
-            Binary.new(const_.operator.try_into()?, [col.clone(), lit(scalar)])
+            Binary.new_expr(const_.operator.try_into()?, [col.clone(), lit(scalar)])
         }
         TableFilterClass::ConjunctionAnd(conj_and) => {
             let Some(children) = conj_and

vortex-duckdb/src/scan.rs

@@ -6,22 +6,22 @@ use std::ffi::CString;
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 use std::pin::Pin;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::task::{Context, Poll};
 
 use async_compat::Compat;
 use futures::stream::{BoxStream, SelectAll};
-use futures::{stream, FutureExt, Stream, StreamExt};
+use futures::{FutureExt, Stream, StreamExt, stream};
 use itertools::Itertools;
 use num_traits::AsPrimitive;
 use url::Url;
 use vortex::dtype::FieldNames;
-use vortex::error::{vortex_bail, vortex_err, VortexExpect, VortexResult};
-use vortex::expr::{and, and_collect, col, lit, root, select, Expression};
+use vortex::error::{VortexExpect, VortexResult, vortex_bail, vortex_err};
+use vortex::expr::{Expression, and, and_collect, col, lit, root, select};
 use vortex::file::{OpenOptionsSessionExt, VortexFile, VortexOpenOptions};
-use vortex::io::runtime::current::ThreadSafeIterator;
 use vortex::io::runtime::BlockingRuntime;
+use vortex::io::runtime::current::ThreadSafeIterator;
 use vortex::{ArrayRef, ToCanonical};
 
 use crate::convert::{try_from_bound_expression, try_from_table_filter};
@@ -33,7 +33,7 @@ use crate::duckdb::{
 use crate::exporter::{ArrayExporter, ConversionCache};
 use crate::utils::glob::expand_glob;
 use crate::utils::object_store::s3_store;
-use crate::{duckdb, RUNTIME, SESSION};
+use crate::{RUNTIME, SESSION, duckdb};
 
 pub struct VortexBindData {
     first_file: VortexFile,

vortex-expr/src/arbitrary.rs

@@ -7,7 +7,7 @@ use arbitrary::{Result as AResult, Unstructured};
 use vortex_dtype::{DType, FieldName};
 use vortex_scalar::arbitrary::random_scalar;
 
-use crate::{and_collect, col, lit, pack, Binary, Expression, Operator, VTableExt};
+use crate::{Binary, Expression, Operator, VTableExt, and_collect, col, lit, pack};
 
 pub fn projection_expr(u: &mut Unstructured<'_>, dtype: &DType) -> AResult<Option<Expression>> {
     let Some(struct_dtype) = dtype.as_struct_fields_opt() else {
@@ -50,7 +50,7 @@ fn random_comparison(
     dtype: &DType,
 ) -> AResult<Expression> {
     let scalar = random_scalar(u, dtype)?;
-    Ok(Binary.new(
+    Ok(Binary.new_expr(
         arbitrary_comparison_operator(u)?,
         [col(name.clone()), lit(scalar)],
     ))

vortex-expr/src/display.rs

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::Expression;
 use std::fmt::{Display, Formatter};
 
+use crate::Expression;
+
 pub enum DisplayFormat {
     Compact,
     Tree,
@@ -48,8 +49,6 @@ impl Display for ExpressionDebug<'_> {
 
 #[cfg(test)]
 mod tests {
-    use crate::exprs::pack::pack;
-    use crate::exprs::select::select_exclude;
     use vortex_array::compute::{BetweenOptions, StrictComparison};
     use vortex_dtype::{DType, Nullability, PType};
 
@@ -59,8 +58,9 @@ mod tests {
     use crate::exprs::get_item::get_item;
     use crate::exprs::literal::lit;
     use crate::exprs::not::not;
+    use crate::exprs::pack::pack;
     use crate::exprs::root::root;
-    use crate::exprs::select::select;
+    use crate::exprs::select::{select, select_exclude};
 
     #[test]
     fn tree_display_getitem() {

vortex-expr/src/exprs/between.rs

@@ -1,13 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use prost::Message;
 use std::fmt::Formatter;
-use vortex_array::compute::{between as between_compute, BetweenOptions};
+
+use prost::Message;
 use vortex_array::ArrayRef;
+use vortex_array::compute::{BetweenOptions, between as between_compute};
 use vortex_dtype::DType;
 use vortex_dtype::DType::Bool;
-use vortex_error::{vortex_bail, VortexExpect, VortexResult};
+use vortex_error::{VortexExpect, VortexResult, vortex_bail};
 use vortex_proto::expr as pb;
 
 use crate::exprs::binary::Binary;
@@ -163,12 +164,12 @@ impl ExprInstance<'_, Between> {
         let lower = self.children()[1].clone();
         let upper = self.children()[2].clone();
 
-        let lhs = Binary.new(
+        let lhs = Binary.new_expr(
             options.lower_strict.to_operator().into(),
             [lower, arr.clone()],
         );
-        let rhs = Binary.new(options.upper_strict.to_operator().into(), [arr, upper]);
-        Binary.new(Operator::And, [lhs, rhs])
+        let rhs = Binary.new_expr(options.upper_strict.to_operator().into(), [arr, upper]);
+        Binary.new_expr(Operator::And, [lhs, rhs])
     }
 }
 
@@ -194,7 +195,7 @@ pub fn between(
     options: BetweenOptions,
 ) -> Expression {
     Between
-        .try_new(options, [arr.clone(), lower.clone(), upper.clone()])
+        .try_new_expr(options, [arr, lower, upper])
         .vortex_expect("Failed to create Between expression")
 }