format

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

java/vortex-spark/src/main/java/dev/vortex/spark/read/SparkPredicateToVortexExpression.java

@@ -6,6 +6,13 @@
 import dev.vortex.api.Expression;
 import dev.vortex.api.Expression.BinaryOp;
 import dev.vortex.api.Expression.TimeUnit;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 import org.apache.spark.sql.connector.expressions.filter.AlwaysFalse;
@@ -33,14 +40,6 @@
 import org.apache.spark.sql.types.TimestampType;
 import org.apache.spark.unsafe.types.UTF8String;
 
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
 /**
  * Translates {@link Predicate Spark V2 predicates} into Vortex {@link Expression}s for predicate pushdown.
  *
@@ -50,16 +49,15 @@
  */
 final class SparkPredicateToVortexExpression {
 
-    private SparkPredicateToVortexExpression() {
-    }
+    private SparkPredicateToVortexExpression() {}
 
     /**
      * Returns true if the given Spark predicate can be translated to a Vortex expression and every named reference
      * resolves to a real field path under {@code dataColumnTypes}.
      *
      * <p>{@code dataColumnTypes} maps each pushable top-level column name to its top-level Spark {@link DataType};
-     * partition columns and columns the scan does not project should not appear in the map. For nested references
-     * (for example {@code info.email}) the validator walks the named reference part by part, descending into
+     * partition columns and columns the scan does not project should not appear in the map. For nested references (for
+     * example {@code info.email}) the validator walks the named reference part by part, descending into
      * {@link StructType} fields so that {@code info} must be a struct that contains an {@code email} field.
      *
      * <p>This is the cheap check used in {@code SupportsPushDownV2Filters.pushPredicates} to decide which predicates
@@ -77,8 +75,7 @@ static boolean isPushable(Predicate predicate, Map<String, DataType> dataColumnT
 
     /**
      * Walks {@code parts} against {@code dataColumnTypes}, descending through {@link StructType} fields for
-     * dot-separated nested references. Returns true only when every part resolves to an actual field in the
-     * schema.
+     * dot-separated nested references. Returns true only when every part resolves to an actual field in the schema.
      */
     private static boolean resolveFieldPath(String[] parts, Map<String, DataType> dataColumnTypes) {
         if (parts.length == 0) {
@@ -102,7 +99,9 @@ private static boolean resolveFieldPath(String[] parts, Map<String, DataType> da
     }
 
     private static Optional<StructField> findField(StructType struct, String name) {
-        return Arrays.stream(struct.fields()).filter(structField -> structField.name().equals(name)).findFirst();
+        return Arrays.stream(struct.fields())
+                .filter(structField -> structField.name().equals(name))
+                .findFirst();
     }
 
     private static boolean isStructurallyPushable(Predicate predicate) {
@@ -135,7 +134,7 @@ private static boolean isStructurallyPushable(Predicate predicate) {
                 yield true;
             }
             case "STARTS_WITH", "ENDS_WITH", "CONTAINS" ->
-                    children.length == 2 && isPushableFieldRef(children[0]) && isPushableStringLiteral(children[1]);
+                children.length == 2 && isPushableFieldRef(children[0]) && isPushableStringLiteral(children[1]);
             // `BOOLEAN_EXPRESSION` wraps a bare boolean-valued child. We only handle the case
             // where the child itself is a field reference (e.g. `WHERE bool_col`).
             case "BOOLEAN_EXPRESSION" -> children.length == 1 && isPushableFieldRef(children[0]);
@@ -178,12 +177,12 @@ static Optional<Expression> convert(Predicate predicate) {
             case "=", "<>", "!=", ">", ">=", "<", "<=" -> convertComparison(predicate.name(), children);
             case "IS_NULL" -> children.length == 1 ? columnOf(children[0]).map(Expression::isNull) : Optional.empty();
             case "IS_NOT_NULL" ->
-                    children.length == 1 ? columnOf(children[0]).map(Expression::isNotNull) : Optional.empty();
+                children.length == 1 ? columnOf(children[0]).map(Expression::isNotNull) : Optional.empty();
             case "IN" -> convertIn(children);
             case "STARTS_WITH" ->
-                    convertStringMatch(children, /* leadingWildcard= */ false, /* trailingWildcard= */ true);
+                convertStringMatch(children, /* leadingWildcard= */ false, /* trailingWildcard= */ true);
             case "ENDS_WITH" ->
-                    convertStringMatch(children, /* leadingWildcard= */ true, /* trailingWildcard= */ false);
+                convertStringMatch(children, /* leadingWildcard= */ true, /* trailingWildcard= */ false);
             case "CONTAINS" -> convertStringMatch(children, /* leadingWildcard= */ true, /* trailingWildcard= */ true);
             case "BOOLEAN_EXPRESSION" -> children.length == 1 ? columnOf(children[0]) : Optional.empty();
             default -> Optional.empty();
@@ -327,9 +326,7 @@ private static boolean isFieldRefExpr(org.apache.spark.sql.connector.expressions
         return expr instanceof NamedReference;
     }
 
-    /**
-     * Returns the Vortex column expression for a Spark named reference, walking nested struct fields.
-     */
+    /** Returns the Vortex column expression for a Spark named reference, walking nested struct fields. */
     private static Optional<Expression> columnOf(org.apache.spark.sql.connector.expressions.Expression expr) {
         if (!(expr instanceof NamedReference)) {
             return Optional.empty();
@@ -501,9 +498,7 @@ private static Optional<Expression> convertLiteral(Object value, DataType dataTy
         return Optional.empty();
     }
 
-    /**
-     * Extract the unscaled integer value of a Spark decimal literal at the supplied {@code scale}.
-     */
+    /** Extract the unscaled integer value of a Spark decimal literal at the supplied {@code scale}. */
     private static BigInteger unscaledValueOf(Object value, int scale) {
         BigDecimal decimal;
         if (value instanceof Decimal) {

java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScan.java

@@ -3,11 +3,11 @@
 
 package dev.vortex.spark.read;
 
-import java.util.Arrays;
 import dev.vortex.api.DataSource;
 import dev.vortex.api.Session;
 import dev.vortex.jni.NativeFiles;
 import dev.vortex.spark.VortexSparkSession;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -16,8 +16,8 @@
 import java.util.stream.Stream;
 import org.apache.spark.sql.connector.catalog.CatalogV2Util;
 import org.apache.spark.sql.connector.catalog.Column;
-import org.apache.spark.sql.connector.expressions.filter.Predicate;
 import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.filter.Predicate;
 import org.apache.spark.sql.connector.read.Batch;
 import org.apache.spark.sql.connector.read.Scan;
 import org.apache.spark.sql.connector.read.Statistics;
@@ -59,7 +59,7 @@ public VortexScan(
             List<String> paths,
             List<Column> tableColumns,
             List<Column> readColumns,
-                Predicate[] pushedPredicates,
+            Predicate[] pushedPredicates,
             Map<String, String> formatOptions) {
         this.paths = paths;
         this.tableColumns = tableColumns;

java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScanBuilder.java

@@ -119,7 +119,12 @@ public Scan build() {
         // Allow empty columns for operations like count() that don't need actual column data
         // If no columns are specified, we'll read the minimal schema needed
 
-        return new VortexScan(paths, List.copyOf(this.tableColumns), List.copyOf(this.readColumns), pushedPredicates, this.formatOptions);
+        return new VortexScan(
+                paths,
+                List.copyOf(this.tableColumns),
+                List.copyOf(this.readColumns),
+                pushedPredicates,
+                this.formatOptions);
     }
 
     /**

vortex-duckdb/src/table_function.rs

@@ -439,7 +439,7 @@ pub fn statistics(bind_data: &TableFunctionBind, column_index: usize) -> Option<
     if children.len() != 1 {
         return None;
     }
-    let MultiLayoutChild::Opened(reader) = &children[0] else {
+    let MultiLayoutChild::Opened { reader, .. } = &children[0] else {
         return None;
     };
     let stats_sets = match reader.as_any().downcast_ref::<FileStatsLayoutReader>() {

vortex-jni/src/data_source.rs

@@ -265,9 +265,9 @@ pub extern "system" fn Java_dev_vortex_jni_NativeDataSource_byteSize(
     try_or_throw(&mut env, |env| {
         let ds = unsafe { NativeDataSource::from_ptr(pointer) };
         let (bytes, precision) = match ds.inner.byte_size() {
-            Some(Precision::Exact(b)) => (b as jlong, 2),
-            Some(Precision::Inexact(b)) => (b as jlong, 1),
-            None => (0, 0),
+            Precision::Exact(b) => (b as jlong, 2),
+            Precision::Inexact(b) => (b as jlong, 1),
+            Precision::Absent => (0, 0),
         };
         out.set_region(env, 0, &[bytes, precision])?;
         Ok(())

vortex-layout/src/scan/multi.rs

@@ -249,10 +249,10 @@ impl DataSource for MultiLayoutDataSource {
         }
     }
 
-    fn byte_size(&self) -> Option<Precision<u64>> {
+    fn byte_size(&self) -> Precision<u64> {
         let total_count = self.children.len() as u64;
         if total_count == 0 {
-            return Some(Precision::exact(0u64));
+            return Precision::exact(0u64);
         }
 
         let mut sum: u64 = 0;
@@ -265,15 +265,15 @@ impl DataSource for MultiLayoutDataSource {
         }
 
         if known_count == 0 {
-            return None;
+            return Precision::Absent;
         }
 
         if known_count == total_count {
-            Some(Precision::exact(sum))
+            Precision::exact(sum)
         } else {
             let avg = sum / known_count;
             let extrapolated = avg.saturating_mul(total_count);
-            Some(Precision::inexact(extrapolated))
+            Precision::inexact(extrapolated)
         }
     }